fix: un-mark batch_size and webcam width/height as advanced (should stay basic)

Amp-Thread-ID: https://ampcode.com/threads/T-019c3236-1417-74aa-82a3-bcb365fbe9d1

comfy/ldm/ace/ace_step15.py

@@ -7,6 +7,67 @@ from comfy.ldm.modules.attention import optimized_attention
 import comfy.model_management
 from comfy.ldm.flux.layers import timestep_embedding
 
+def get_silence_latent(length, device):
+    head = torch.tensor([[[ 0.5707,  0.0982,  0.6909, -0.5658,  0.6266,  0.6996, -0.1365, -0.1291,
+                        -0.0776, -0.1171, -0.2743, -0.8422, -0.1168,  1.5539, -4.6936,  0.7436,
+                        -1.1846, -0.2637,  0.6933, -6.7266,  0.0966, -0.1187, -0.3501, -1.1736,
+                        0.0587, -2.0517, -1.3651,  0.7508, -0.2490, -1.3548, -0.1290, -0.7261,
+                        1.1132, -0.3249,  0.2337,  0.3004,  0.6605, -0.0298, -0.1989, -0.4041,
+                        0.2843, -1.0963, -0.5519,  0.2639, -1.0436, -0.1183,  0.0640,  0.4460,
+                        -1.1001, -0.6172, -1.3241,  1.1379,  0.5623, -0.1507, -0.1963, -0.4742,
+                        -2.4697,  0.5302,  0.5381,  0.4636, -0.1782, -0.0687,  1.0333,  0.4202],
+                        [ 0.3040, -0.1367,  0.6200,  0.0665, -0.0642,  0.4655, -0.1187, -0.0440,
+                        0.2941, -0.2753,  0.0173, -0.2421, -0.0147,  1.5603, -2.7025,  0.7907,
+                        -0.9736, -0.0682,  0.1294, -5.0707, -0.2167,  0.3302, -0.1513, -0.8100,
+                        -0.3894, -0.2884, -0.3149,  0.8660, -0.3817, -1.7061,  0.5824, -0.4840,
+                        0.6938,  0.1859,  0.1753,  0.3081,  0.0195,  0.1403, -0.0754, -0.2091,
+                        0.1251, -0.1578, -0.4968, -0.1052, -0.4554, -0.0320,  0.1284,  0.4974,
+                        -1.1889, -0.0344, -0.8313,  0.2953,  0.5445, -0.6249, -0.1595, -0.0682,
+                        -3.1412,  0.0484,  0.4153,  0.8260, -0.1526, -0.0625,  0.5366,  0.8473],
+                        [ 5.3524e-02, -1.7534e-01,  5.4443e-01, -4.3501e-01, -2.1317e-03,
+                        3.7200e-01, -4.0143e-03, -1.5516e-01, -1.2968e-01, -1.5375e-01,
+                        -7.7107e-02, -2.0593e-01, -3.2780e-01,  1.5142e+00, -2.6101e+00,
+                        5.8698e-01, -1.2716e+00, -2.4773e-01, -2.7933e-02, -5.0799e+00,
+                        1.1601e-01,  4.0987e-01, -2.2030e-02, -6.6495e-01, -2.0995e-01,
+                        -6.3474e-01, -1.5893e-01,  8.2745e-01, -2.2992e-01, -1.6816e+00,
+                        5.4440e-01, -4.9579e-01,  5.5128e-01,  3.0477e-01,  8.3052e-02,
+                        -6.1782e-02,  5.9036e-03,  2.9553e-01, -8.0645e-02, -1.0060e-01,
+                        1.9144e-01, -3.8124e-01, -7.2949e-01,  2.4520e-02, -5.0814e-01,
+                        2.3977e-01,  9.2943e-02,  3.9256e-01, -1.1993e+00, -3.2752e-01,
+                        -7.2707e-01,  2.9476e-01,  4.3542e-01, -8.8597e-01, -4.1686e-01,
+                        -8.5390e-02, -2.9018e+00,  6.4988e-02,  5.3945e-01,  9.1988e-01,
+                        5.8762e-02, -7.0098e-02,  6.4772e-01,  8.9118e-01],
+                        [-3.2225e-02, -1.3195e-01,  5.6411e-01, -5.4766e-01, -5.2170e-03,
+                        3.1425e-01, -5.4367e-02, -1.9419e-01, -1.3059e-01, -1.3660e-01,
+                        -9.0984e-02, -1.9540e-01, -2.5590e-01,  1.5440e+00, -2.6349e+00,
+                        6.8273e-01, -1.2532e+00, -1.9810e-01, -2.2793e-02, -5.0506e+00,
+                        1.8818e-01,  5.0109e-01,  7.3546e-03, -6.8771e-01, -3.0676e-01,
+                        -7.3257e-01, -1.6687e-01,  9.2232e-01, -1.8987e-01, -1.7267e+00,
+                        5.3355e-01, -5.3179e-01,  4.4953e-01,  2.8820e-01,  1.3012e-01,
+                        -2.0943e-01, -1.1348e-01,  3.3929e-01, -1.5069e-01, -1.2919e-01,
+                        1.8929e-01, -3.6166e-01, -8.0756e-01,  6.6387e-02, -5.8867e-01,
+                        1.6978e-01,  1.0134e-01,  3.3877e-01, -1.2133e+00, -3.2492e-01,
+                        -8.1237e-01,  3.8101e-01,  4.3765e-01, -8.0596e-01, -4.4531e-01,
+                        -4.7513e-02, -2.9266e+00,  1.1741e-03,  4.5123e-01,  9.3075e-01,
+                        5.3688e-02, -1.9621e-01,  6.4530e-01,  9.3870e-01]]], device=device).movedim(-1, 1)
+
+    silence_latent = torch.tensor([[[-1.3672e-01, -1.5820e-01,  5.8594e-01, -5.7422e-01,  3.0273e-02,
+                                2.7930e-01, -2.5940e-03, -2.0703e-01, -1.6113e-01, -1.4746e-01,
+                                -2.7710e-02, -1.8066e-01, -2.9688e-01,  1.6016e+00, -2.6719e+00,
+                                7.7734e-01, -1.3516e+00, -1.9434e-01, -7.1289e-02, -5.0938e+00,
+                                2.4316e-01,  4.7266e-01,  4.6387e-02, -6.6406e-01, -2.1973e-01,
+                                -6.7578e-01, -1.5723e-01,  9.5312e-01, -2.0020e-01, -1.7109e+00,
+                                5.8984e-01, -5.7422e-01,  5.1562e-01,  2.8320e-01,  1.4551e-01,
+                                -1.8750e-01, -5.9814e-02,  3.6719e-01, -1.0059e-01, -1.5723e-01,
+                                2.0605e-01, -4.3359e-01, -8.2812e-01,  4.5654e-02, -6.6016e-01,
+                                1.4844e-01,  9.4727e-02,  3.8477e-01, -1.2578e+00, -3.3203e-01,
+                                -8.5547e-01,  4.3359e-01,  4.2383e-01, -8.9453e-01, -5.0391e-01,
+                                -5.6152e-02, -2.9219e+00, -2.4658e-02,  5.0391e-01,  9.8438e-01,
+                                7.2754e-02, -2.1582e-01,  6.3672e-01,  1.0000e+00]]], device=device).movedim(-1, 1).repeat(1, 1, length)
+    silence_latent[:, :, :head.shape[-1]] = head
+    return silence_latent
+
+
 def get_layer_class(operations, layer_name):
     if operations is not None and hasattr(operations, layer_name):
         return getattr(operations, layer_name)
@@ -183,7 +244,7 @@ class AceStepAttention(nn.Module):
             else:
                 attn_bias = window_bias
 
-        attn_output = optimized_attention(query_states, key_states, value_states, self.num_heads, attn_bias, skip_reshape=True)
+        attn_output = optimized_attention(query_states, key_states, value_states, self.num_heads, attn_bias, skip_reshape=True, low_precision_attention=False)
         attn_output = self.o_proj(attn_output)
 
         return attn_output
@@ -677,7 +738,7 @@ class AttentionPooler(nn.Module):
     def forward(self, x):
         B, T, P, D = x.shape
         x = self.embed_tokens(x)
-        special = self.special_token.expand(B, T, 1, -1)
+        special = comfy.model_management.cast_to(self.special_token, device=x.device, dtype=x.dtype).expand(B, T, 1, -1)
         x = torch.cat([special, x], dim=2)
         x = x.view(B * T, P + 1, D)
 
@@ -728,7 +789,7 @@ class FSQ(nn.Module):
         self.register_buffer('implicit_codebook', implicit_codebook, persistent=False)
 
     def bound(self, z):
-        levels_minus_1 = (self._levels - 1).to(z.dtype)
+        levels_minus_1 = (comfy.model_management.cast_to(self._levels, device=z.device, dtype=z.dtype) - 1)
         scale = 2. / levels_minus_1
         bracket = (levels_minus_1 * (torch.tanh(z) + 1) / 2.) + 0.5
 
@@ -743,8 +804,8 @@ class FSQ(nn.Module):
         return codes_non_centered.float() * (2. / (self._levels.float() - 1)) - 1.
 
     def codes_to_indices(self, zhat):
-        zhat_normalized = (zhat + 1.) / (2. / (self._levels.to(zhat.dtype) - 1))
-        return (zhat_normalized * self._basis.to(zhat.dtype)).sum(dim=-1).round().to(torch.int32)
+        zhat_normalized = (zhat + 1.) / (2. / (comfy.model_management.cast_to(self._levels, device=zhat.device, dtype=zhat.dtype) - 1))
+        return (zhat_normalized * comfy.model_management.cast_to(self._basis, device=zhat.device, dtype=zhat.dtype)).sum(dim=-1).round().to(torch.int32)
 
     def forward(self, z):
         orig_dtype = z.dtype
@@ -826,7 +887,7 @@ class ResidualFSQ(nn.Module):
         x = self.project_in(x)
 
         if hasattr(self, 'soft_clamp_input_value'):
-            sc_val = self.soft_clamp_input_value.to(x.dtype)
+            sc_val = comfy.model_management.cast_to(self.soft_clamp_input_value, device=x.device, dtype=x.dtype)
             x = (x / sc_val).tanh() * sc_val
 
         quantized_out = torch.tensor(0., device=x.device, dtype=x.dtype)
@@ -834,7 +895,7 @@ class ResidualFSQ(nn.Module):
         all_indices = []
 
         for layer, scale in zip(self.layers, self.scales):
-            scale = scale.to(residual.dtype)
+            scale = comfy.model_management.cast_to(scale, device=x.device, dtype=x.dtype)
 
             quantized, indices = layer(residual / scale)
             quantized = quantized * scale
@@ -1035,28 +1096,26 @@ class AceStepConditionGenerationModel(nn.Module):
                     audio_codes = torch.nn.functional.pad(audio_codes, (0, math.ceil(src_latents.shape[1] / 5) - audio_codes.shape[1]), "constant", 35847)
                 lm_hints_5Hz = self.tokenizer.quantizer.get_output_from_indices(audio_codes, dtype=text_hidden_states.dtype)
             else:
-                assert False
-                # TODO ?
+                lm_hints_5Hz, indices = self.tokenizer.tokenize(refer_audio_acoustic_hidden_states_packed)
 
             lm_hints = self.detokenizer(lm_hints_5Hz)
 
         lm_hints = lm_hints[:, :src_latents.shape[1], :]
-        if is_covers is None:
+        if is_covers is None or is_covers is True:
             src_latents = lm_hints
-        else:
-            src_latents = torch.where(is_covers.unsqueeze(-1).unsqueeze(-1) > 0, lm_hints, src_latents)
+        elif is_covers is False:
+            src_latents = refer_audio_acoustic_hidden_states_packed
 
         context_latents = torch.cat([src_latents, chunk_masks.to(src_latents.dtype)], dim=-1)
 
         return encoder_hidden, encoder_mask, context_latents
 
-    def forward(self, x, timestep, context, lyric_embed=None, refer_audio=None, audio_codes=None, **kwargs):
+    def forward(self, x, timestep, context, lyric_embed=None, refer_audio=None, audio_codes=None, is_covers=None, **kwargs):
         text_attention_mask = None
         lyric_attention_mask = None
         refer_audio_order_mask = None
         attention_mask = None
         chunk_masks = None
-        is_covers = None
         src_latents = None
         precomputed_lm_hints_25Hz = None
         lyric_hidden_states = lyric_embed
@@ -1068,7 +1127,7 @@ class AceStepConditionGenerationModel(nn.Module):
         if refer_audio_order_mask is None:
             refer_audio_order_mask = torch.zeros((x.shape[0],), device=x.device, dtype=torch.long)
 
-        if src_latents is None and is_covers is None:
+        if src_latents is None:
             src_latents = x
 
         if chunk_masks is None:

comfy/ldm/modules/attention.py

@@ -524,6 +524,9 @@ def attention_pytorch(q, k, v, heads, mask=None, attn_precision=None, skip_resha
 
 @wrap_attn
 def attention_sage(q, k, v, heads, mask=None, attn_precision=None, skip_reshape=False, skip_output_reshape=False, **kwargs):
+    if kwargs.get("low_precision_attention", True) is False:
+        return attention_pytorch(q, k, v, heads, mask=mask, skip_reshape=skip_reshape, skip_output_reshape=skip_output_reshape, **kwargs)
+
     exception_fallback = False
     if skip_reshape:
         b, _, _, dim_head = q.shape

comfy/model_base.py

@@ -147,11 +147,11 @@ class BaseModel(torch.nn.Module):
                 self.diffusion_model.to(memory_format=torch.channels_last)
                 logging.debug("using channels last mode for diffusion model")
             logging.info("model weight dtype {}, manual cast: {}".format(self.get_dtype(), self.manual_cast_dtype))
+            comfy.model_management.archive_model_dtypes(self.diffusion_model)
+
         self.model_type = model_type
         self.model_sampling = model_sampling(model_config, model_type)
 
-        comfy.model_management.archive_model_dtypes(self.diffusion_model)
-
         self.adm_channels = unet_config.get("adm_in_channels", None)
         if self.adm_channels is None:
             self.adm_channels = 0
@@ -1548,6 +1548,7 @@ class ACEStep15(BaseModel):
     def extra_conds(self, **kwargs):
         out = super().extra_conds(**kwargs)
         device = kwargs["device"]
+        noise = kwargs["noise"]
 
         cross_attn = kwargs.get("cross_attn", None)
         if cross_attn is not None:
@@ -1559,27 +1560,22 @@ class ACEStep15(BaseModel):
 
         refer_audio = kwargs.get("reference_audio_timbre_latents", None)
         if refer_audio is None or len(refer_audio) == 0:
-            refer_audio = torch.tensor([[[-1.3672e-01, -1.5820e-01,  5.8594e-01, -5.7422e-01,  3.0273e-02,
-                                        2.7930e-01, -2.5940e-03, -2.0703e-01, -1.6113e-01, -1.4746e-01,
-                                        -2.7710e-02, -1.8066e-01, -2.9688e-01,  1.6016e+00, -2.6719e+00,
-                                        7.7734e-01, -1.3516e+00, -1.9434e-01, -7.1289e-02, -5.0938e+00,
-                                        2.4316e-01,  4.7266e-01,  4.6387e-02, -6.6406e-01, -2.1973e-01,
-                                        -6.7578e-01, -1.5723e-01,  9.5312e-01, -2.0020e-01, -1.7109e+00,
-                                        5.8984e-01, -5.7422e-01,  5.1562e-01,  2.8320e-01,  1.4551e-01,
-                                        -1.8750e-01, -5.9814e-02,  3.6719e-01, -1.0059e-01, -1.5723e-01,
-                                        2.0605e-01, -4.3359e-01, -8.2812e-01,  4.5654e-02, -6.6016e-01,
-                                        1.4844e-01,  9.4727e-02,  3.8477e-01, -1.2578e+00, -3.3203e-01,
-                                        -8.5547e-01,  4.3359e-01,  4.2383e-01, -8.9453e-01, -5.0391e-01,
-                                        -5.6152e-02, -2.9219e+00, -2.4658e-02,  5.0391e-01,  9.8438e-01,
-                                        7.2754e-02, -2.1582e-01,  6.3672e-01,  1.0000e+00]]], device=device).movedim(-1, 1).repeat(1, 1, 750)
+            refer_audio = comfy.ldm.ace.ace_step15.get_silence_latent(noise.shape[2], device)
+            pass_audio_codes = True
         else:
-            refer_audio = refer_audio[-1]
+            refer_audio = refer_audio[-1][:, :, :noise.shape[2]]
+            out['is_covers'] = comfy.conds.CONDConstant(True)
+            pass_audio_codes = False
+
+        if pass_audio_codes:
+            audio_codes = kwargs.get("audio_codes", None)
+            if audio_codes is not None:
+                out['audio_codes'] = comfy.conds.CONDRegular(torch.tensor(audio_codes, device=device))
+                refer_audio = refer_audio[:, :, :750]
+            else:
+                out['is_covers'] = comfy.conds.CONDConstant(False)
+
         out['refer_audio'] = comfy.conds.CONDRegular(refer_audio)
-
-        audio_codes = kwargs.get("audio_codes", None)
-        if audio_codes is not None:
-            out['audio_codes'] = comfy.conds.CONDRegular(torch.tensor(audio_codes, device=device))
-
         return out
 
 class Omnigen2(BaseModel):

comfy/ops.py

@@ -54,6 +54,8 @@ try:
             SDPA_BACKEND_PRIORITY.insert(0, SDPBackend.CUDNN_ATTENTION)
 
             def scaled_dot_product_attention(q, k, v, *args, **kwargs):
+                if q.nelement() < 1024 * 128:  # arbitrary number, for small inputs cudnn attention seems slower
+                    return torch.nn.functional.scaled_dot_product_attention(q, k, v, *args, **kwargs)
                 with sdpa_kernel(SDPA_BACKEND_PRIORITY, set_priority=True):
                     return torch.nn.functional.scaled_dot_product_attention(q, k, v, *args, **kwargs)
         else:

comfy/sd.py

@@ -976,7 +976,7 @@ class VAE:
         if overlap is not None:
             args["overlap"] = overlap
 
-        if dims == 1:
+        if dims == 1 or self.extra_1d_channel is not None:
             args.pop("tile_y")
             output = self.decode_tiled_1d(samples, **args)
         elif dims == 2:

comfy/text_encoders/ace15.py

@@ -3,6 +3,7 @@ import comfy.text_encoders.llama
 from comfy import sd1_clip
 import torch
 import math
+import yaml
 import comfy.utils
 
 
@@ -101,9 +102,7 @@ def sample_manual_loop_no_classes(
     return output_audio_codes
 
 
-def generate_audio_codes(model, positive, negative, min_tokens=1, max_tokens=1024, seed=0):
-    cfg_scale = 2.0
-
+def generate_audio_codes(model, positive, negative, min_tokens=1, max_tokens=1024, seed=0, cfg_scale=2.0, temperature=0.85, top_p=0.9, top_k=0):
     positive = [[token for token, _ in inner_list] for inner_list in positive]
     negative = [[token for token, _ in inner_list] for inner_list in negative]
     positive = positive[0]
@@ -120,34 +119,80 @@ def generate_audio_codes(model, positive, negative, min_tokens=1, max_tokens=102
         positive = [model.special_tokens["pad"]] * pos_pad + positive
 
     paddings = [pos_pad, neg_pad]
-    return sample_manual_loop_no_classes(model, [positive, negative], paddings, cfg_scale=cfg_scale, seed=seed, min_tokens=min_tokens, max_new_tokens=max_tokens)
+    return sample_manual_loop_no_classes(model, [positive, negative], paddings, cfg_scale=cfg_scale, temperature=temperature, top_p=top_p, top_k=top_k, seed=seed, min_tokens=min_tokens, max_new_tokens=max_tokens)
 
 
 class ACE15Tokenizer(sd1_clip.SD1Tokenizer):
     def __init__(self, embedding_directory=None, tokenizer_data={}):
         super().__init__(embedding_directory=embedding_directory, tokenizer_data=tokenizer_data, name="qwen3_06b", tokenizer=Qwen3Tokenizer)
 
+    def _metas_to_cot(self, *, return_yaml: bool = False, **kwargs) -> str:
+        user_metas = {
+            k: kwargs.pop(k)
+            for k in ("bpm", "duration", "keyscale", "timesignature", "language", "caption")
+            if k in kwargs
+        }
+        timesignature = user_metas.get("timesignature")
+        if isinstance(timesignature, str) and timesignature.endswith("/4"):
+            user_metas["timesignature"] = timesignature.rsplit("/", 1)[0]
+        user_metas = {
+            k: v if not isinstance(v, str) or not v.isdigit() else int(v)
+            for k, v in user_metas.items()
+            if v not in {"unspecified", None}
+        }
+        if len(user_metas):
+            meta_yaml = yaml.dump(user_metas, allow_unicode=True, sort_keys=True).strip()
+        else:
+            meta_yaml = ""
+        return f"<think>\n{meta_yaml}\n</think>" if not return_yaml else meta_yaml
+
+    def _metas_to_cap(self, **kwargs) -> str:
+        use_keys = ("bpm", "duration", "keyscale", "timesignature")
+        user_metas = { k: kwargs.pop(k, "N/A") for k in use_keys }
+        duration = user_metas["duration"]
+        if duration == "N/A":
+            user_metas["duration"] = "30 seconds"
+        elif isinstance(duration, (str, int, float)):
+            user_metas["duration"] = f"{math.ceil(float(duration))} seconds"
+        else:
+            raise TypeError("Unexpected type for duration key, must be str, int or float")
+        return "\n".join(f"- {k}: {user_metas[k]}" for k in use_keys)
+
     def tokenize_with_weights(self, text, return_word_ids=False, **kwargs):
         out = {}
         lyrics = kwargs.get("lyrics", "")
-        bpm = kwargs.get("bpm", 120)
         duration = kwargs.get("duration", 120)
-        keyscale = kwargs.get("keyscale", "C major")
-        timesignature = kwargs.get("timesignature", 2)
-        language = kwargs.get("language", "en")
+        language = kwargs.get("language")
         seed = kwargs.get("seed", 0)
 
+        generate_audio_codes = kwargs.get("generate_audio_codes", True)
+        cfg_scale = kwargs.get("cfg_scale", 2.0)
+        temperature = kwargs.get("temperature", 0.85)
+        top_p = kwargs.get("top_p", 0.9)
+        top_k = kwargs.get("top_k", 0.0)
+
+
         duration = math.ceil(duration)
-        meta_lm = 'bpm: {}\nduration: {}\nkeyscale: {}\ntimesignature: {}'.format(bpm, duration, keyscale, timesignature)
-        lm_template = "<|im_start|>system\n# Instruction\nGenerate audio semantic tokens based on the given conditions:\n\n<|im_end|>\n<|im_start|>user\n# Caption\n{}\n{}\n<|im_end|>\n<|im_start|>assistant\n<think>\n{}\n</think>\n\n<|im_end|>\n"
+        kwargs["duration"] = duration
 
-        meta_cap = '- bpm: {}\n- timesignature: {}\n- keyscale: {}\n- duration: {}\n'.format(bpm, timesignature, keyscale, duration)
-        out["lm_prompt"] = self.qwen3_06b.tokenize_with_weights(lm_template.format(text, lyrics, meta_lm), disable_weights=True)
-        out["lm_prompt_negative"] = self.qwen3_06b.tokenize_with_weights(lm_template.format(text, lyrics, ""), disable_weights=True)
+        cot_text = self._metas_to_cot(caption = text, **kwargs)
+        meta_cap = self._metas_to_cap(**kwargs)
 
-        out["lyrics"] = self.qwen3_06b.tokenize_with_weights("# Languages\n{}\n\n# Lyric{}<|endoftext|><|endoftext|>".format(language, lyrics), return_word_ids, disable_weights=True, **kwargs)
-        out["qwen3_06b"] = self.qwen3_06b.tokenize_with_weights("# Instruction\nGenerate audio semantic tokens based on the given conditions:\n\n# Caption\n{}# Metas\n{}<|endoftext|>\n<|endoftext|>".format(text, meta_cap), return_word_ids, **kwargs)
-        out["lm_metadata"] = {"min_tokens": duration * 5, "seed": seed}
+        lm_template = "<|im_start|>system\n# Instruction\nGenerate audio semantic tokens based on the given conditions:\n\n<|im_end|>\n<|im_start|>user\n# Caption\n{}\n# Lyric\n{}\n<|im_end|>\n<|im_start|>assistant\n{}\n<|im_end|>\n"
+
+        out["lm_prompt"] = self.qwen3_06b.tokenize_with_weights(lm_template.format(text, lyrics, cot_text), disable_weights=True)
+        out["lm_prompt_negative"] = self.qwen3_06b.tokenize_with_weights(lm_template.format(text, lyrics, "<think>\n</think>"), disable_weights=True)
+
+        out["lyrics"] = self.qwen3_06b.tokenize_with_weights("# Languages\n{}\n\n# Lyric\n{}<|endoftext|><|endoftext|>".format(language if language is not None else "", lyrics), return_word_ids, disable_weights=True, **kwargs)
+        out["qwen3_06b"] = self.qwen3_06b.tokenize_with_weights("# Instruction\nGenerate audio semantic tokens based on the given conditions:\n\n# Caption\n{}\n# Metas\n{}\n<|endoftext|>\n<|endoftext|>".format(text, meta_cap), return_word_ids, **kwargs)
+        out["lm_metadata"] = {"min_tokens": duration * 5,
+                              "seed": seed,
+                              "generate_audio_codes": generate_audio_codes,
+                              "cfg_scale": cfg_scale,
+                              "temperature": temperature,
+                              "top_p": top_p,
+                              "top_k": top_k,
+                              }
         return out
 
 
@@ -203,10 +248,14 @@ class ACE15TEModel(torch.nn.Module):
         self.qwen3_06b.set_clip_options({"layer": [0]})
         lyrics_embeds, _, extra_l = self.qwen3_06b.encode_token_weights(token_weight_pairs_lyrics)
 
-        lm_metadata = token_weight_pairs["lm_metadata"]
-        audio_codes = generate_audio_codes(getattr(self, self.lm_model, self.qwen3_06b), token_weight_pairs["lm_prompt"], token_weight_pairs["lm_prompt_negative"], min_tokens=lm_metadata["min_tokens"], max_tokens=lm_metadata["min_tokens"], seed=lm_metadata["seed"])
+        out = {"conditioning_lyrics": lyrics_embeds[:, 0]}
 
-        return base_out, None, {"conditioning_lyrics": lyrics_embeds[:, 0], "audio_codes": [audio_codes]}
+        lm_metadata = token_weight_pairs["lm_metadata"]
+        if lm_metadata["generate_audio_codes"]:
+            audio_codes = generate_audio_codes(getattr(self, self.lm_model, self.qwen3_06b), token_weight_pairs["lm_prompt"], token_weight_pairs["lm_prompt_negative"], min_tokens=lm_metadata["min_tokens"], max_tokens=lm_metadata["min_tokens"], seed=lm_metadata["seed"], cfg_scale=lm_metadata["cfg_scale"], temperature=lm_metadata["temperature"], top_p=lm_metadata["top_p"], top_k=lm_metadata["top_k"])
+            out["audio_codes"] = [audio_codes]
+
+        return base_out, None, out
 
     def set_clip_options(self, options):
         self.qwen3_06b.set_clip_options(options)

comfy_api/latest/_io.py

@@ -1309,7 +1309,6 @@ class NodeInfoV1:
     api_node: bool=None
     price_badge: dict | None = None
     search_aliases: list[str]=None
-    main_category: str=None
 
 
 @dataclass
@@ -1431,8 +1430,6 @@ class Schema:
     """Flags a node as expandable, allowing NodeOutput to include 'expand' property."""
     accept_all_inputs: bool=False
     """When True, all inputs from the prompt will be passed to the node as kwargs, even if not defined in the schema."""
-    main_category: str | None = None
-    """Optional main category for top-level tabs in the node library (e.g., 'Basic', 'Image Tools', 'Partner Nodes')."""
 
     def validate(self):
         '''Validate the schema:
@@ -1539,7 +1536,6 @@ class Schema:
             python_module=getattr(cls, "RELATIVE_PYTHON_MODULE", "nodes"),
             price_badge=self.price_badge.as_dict(self.inputs) if self.price_badge is not None else None,
             search_aliases=self.search_aliases if self.search_aliases else None,
-            main_category=self.main_category,
         )
         return info
 

comfy_api_nodes/nodes_bfl.py

@@ -57,6 +57,7 @@ class FluxProUltraImageNode(IO.ComfyNode):
                     tooltip="Whether to perform upsampling on the prompt. "
                     "If active, automatically modifies the prompt for more creative generation, "
                     "but results are nondeterministic (same seed will not produce exactly the same result).",
+                    advanced=True,
                 ),
                 IO.Int.Input(
                     "seed",
@@ -200,6 +201,7 @@ class FluxKontextProImageNode(IO.ComfyNode):
                     "prompt_upsampling",
                     default=False,
                     tooltip="Whether to perform upsampling on the prompt. If active, automatically modifies the prompt for more creative generation, but results are nondeterministic (same seed will not produce exactly the same result).",
+                    advanced=True,
                 ),
                 IO.Image.Input(
                     "input_image",
@@ -296,6 +298,7 @@ class FluxProExpandNode(IO.ComfyNode):
                     tooltip="Whether to perform upsampling on the prompt. "
                     "If active, automatically modifies the prompt for more creative generation, "
                     "but results are nondeterministic (same seed will not produce exactly the same result).",
+                    advanced=True,
                 ),
                 IO.Int.Input(
                     "top",
@@ -433,6 +436,7 @@ class FluxProFillNode(IO.ComfyNode):
                     tooltip="Whether to perform upsampling on the prompt. "
                     "If active, automatically modifies the prompt for more creative generation, "
                     "but results are nondeterministic (same seed will not produce exactly the same result).",
+                    advanced=True,
                 ),
                 IO.Float.Input(
                     "guidance",
@@ -577,6 +581,7 @@ class Flux2ProImageNode(IO.ComfyNode):
                     default=True,
                     tooltip="Whether to perform upsampling on the prompt. "
                     "If active, automatically modifies the prompt for more creative generation.",
+                    advanced=True,
                 ),
                 IO.Image.Input("images", optional=True, tooltip="Up to 9 images to be used as references."),
             ],

comfy_api_nodes/nodes_bytedance.py

@@ -114,6 +114,7 @@ class ByteDanceImageNode(IO.ComfyNode):
                     default=False,
                     tooltip='Whether to add an "AI generated" watermark to the image',
                     optional=True,
+                    advanced=True,
                 ),
             ],
             outputs=[
@@ -259,12 +260,14 @@ class ByteDanceSeedreamNode(IO.ComfyNode):
                     default=False,
                     tooltip='Whether to add an "AI generated" watermark to the image.',
                     optional=True,
+                    advanced=True,
                 ),
                 IO.Boolean.Input(
                     "fail_on_partial",
                     default=True,
                     tooltip="If enabled, abort execution if any requested images are missing or return an error.",
                     optional=True,
+                    advanced=True,
                 ),
             ],
             outputs=[
@@ -432,18 +435,21 @@ class ByteDanceTextToVideoNode(IO.ComfyNode):
                     tooltip="Specifies whether to fix the camera. The platform appends an instruction "
                     "to fix the camera to your prompt, but does not guarantee the actual effect.",
                     optional=True,
+                    advanced=True,
                 ),
                 IO.Boolean.Input(
                     "watermark",
                     default=False,
                     tooltip='Whether to add an "AI generated" watermark to the video.',
                     optional=True,
+                    advanced=True,
                 ),
                 IO.Boolean.Input(
                     "generate_audio",
                     default=False,
                     tooltip="This parameter is ignored for any model except seedance-1-5-pro.",
                     optional=True,
+                    advanced=True,
                 ),
             ],
             outputs=[
@@ -561,18 +567,21 @@ class ByteDanceImageToVideoNode(IO.ComfyNode):
                     tooltip="Specifies whether to fix the camera. The platform appends an instruction "
                     "to fix the camera to your prompt, but does not guarantee the actual effect.",
                     optional=True,
+                    advanced=True,
                 ),
                 IO.Boolean.Input(
                     "watermark",
                     default=False,
                     tooltip='Whether to add an "AI generated" watermark to the video.',
                     optional=True,
+                    advanced=True,
                 ),
                 IO.Boolean.Input(
                     "generate_audio",
                     default=False,
                     tooltip="This parameter is ignored for any model except seedance-1-5-pro.",
                     optional=True,
+                    advanced=True,
                 ),
             ],
             outputs=[
@@ -694,18 +703,21 @@ class ByteDanceFirstLastFrameNode(IO.ComfyNode):
                     tooltip="Specifies whether to fix the camera. The platform appends an instruction "
                     "to fix the camera to your prompt, but does not guarantee the actual effect.",
                     optional=True,
+                    advanced=True,
                 ),
                 IO.Boolean.Input(
                     "watermark",
                     default=False,
                     tooltip='Whether to add an "AI generated" watermark to the video.',
                     optional=True,
+                    advanced=True,
                 ),
                 IO.Boolean.Input(
                     "generate_audio",
                     default=False,
                     tooltip="This parameter is ignored for any model except seedance-1-5-pro.",
                     optional=True,
+                    advanced=True,
                 ),
             ],
             outputs=[
@@ -834,6 +846,7 @@ class ByteDanceImageReferenceNode(IO.ComfyNode):
                     default=False,
                     tooltip='Whether to add an "AI generated" watermark to the video.',
                     optional=True,
+                    advanced=True,
                 ),
             ],
             outputs=[

comfy_api_nodes/nodes_gemini.py

@@ -308,6 +308,7 @@ class GeminiNode(IO.ComfyNode):
                     default="",
                     optional=True,
                     tooltip="Foundational instructions that dictate an AI's behavior.",
+                    advanced=True,
                 ),
             ],
             outputs=[
@@ -585,6 +586,7 @@ class GeminiImage(IO.ComfyNode):
                     tooltip="Choose 'IMAGE' for image-only output, or "
                     "'IMAGE+TEXT' to return both the generated image and a text response.",
                     optional=True,
+                    advanced=True,
                 ),
                 IO.String.Input(
                     "system_prompt",
@@ -592,6 +594,7 @@ class GeminiImage(IO.ComfyNode):
                     default=GEMINI_IMAGE_SYS_PROMPT,
                     optional=True,
                     tooltip="Foundational instructions that dictate an AI's behavior.",
+                    advanced=True,
                 ),
             ],
             outputs=[
@@ -706,6 +709,7 @@ class GeminiImage2(IO.ComfyNode):
                     options=["IMAGE+TEXT", "IMAGE"],
                     tooltip="Choose 'IMAGE' for image-only output, or "
                     "'IMAGE+TEXT' to return both the generated image and a text response.",
+                    advanced=True,
                 ),
                 IO.Image.Input(
                     "images",
@@ -725,6 +729,7 @@ class GeminiImage2(IO.ComfyNode):
                     default=GEMINI_IMAGE_SYS_PROMPT,
                     optional=True,
                     tooltip="Foundational instructions that dictate an AI's behavior.",
+                    advanced=True,
                 ),
             ],
             outputs=[

comfy_api_nodes/nodes_hunyuan3d.py

@@ -37,7 +37,6 @@ class TencentTextToModelNode(IO.ComfyNode):
             node_id="TencentTextToModelNode",
             display_name="Hunyuan3D: Text to Model (Pro)",
             category="api node/3d/Tencent",
-            main_category="3D",
             inputs=[
                 IO.Combo.Input(
                     "model",
@@ -148,7 +147,6 @@ class TencentImageToModelNode(IO.ComfyNode):
             node_id="TencentImageToModelNode",
             display_name="Hunyuan3D: Image(s) to Model (Pro)",
             category="api node/3d/Tencent",
-            main_category="3D",
             inputs=[
                 IO.Combo.Input(
                     "model",

comfy_api_nodes/nodes_ideogram.py

@@ -261,6 +261,7 @@ class IdeogramV1(IO.ComfyNode):
                     default="AUTO",
                     tooltip="Determine if MagicPrompt should be used in generation",
                     optional=True,
+                    advanced=True,
                 ),
                 IO.Int.Input(
                     "seed",
@@ -394,6 +395,7 @@ class IdeogramV2(IO.ComfyNode):
                     default="AUTO",
                     tooltip="Determine if MagicPrompt should be used in generation",
                     optional=True,
+                    advanced=True,
                 ),
                 IO.Int.Input(
                     "seed",
@@ -411,6 +413,7 @@ class IdeogramV2(IO.ComfyNode):
                     default="NONE",
                     tooltip="Style type for generation (V2 only)",
                     optional=True,
+                    advanced=True,
                 ),
                 IO.String.Input(
                     "negative_prompt",
@@ -564,6 +567,7 @@ class IdeogramV3(IO.ComfyNode):
                     default="AUTO",
                     tooltip="Determine if MagicPrompt should be used in generation",
                     optional=True,
+                    advanced=True,
                 ),
                 IO.Int.Input(
                     "seed",
@@ -590,6 +594,7 @@ class IdeogramV3(IO.ComfyNode):
                     default="DEFAULT",
                     tooltip="Controls the trade-off between generation speed and quality",
                     optional=True,
+                    advanced=True,
                 ),
                 IO.Image.Input(
                     "character_image",

comfy_api_nodes/nodes_kling.py

@@ -1936,7 +1936,6 @@ class KlingLipSyncAudioToVideoNode(IO.ComfyNode):
             node_id="KlingLipSyncAudioToVideoNode",
             display_name="Kling Lip Sync Video with Audio",
             category="api node/video/Kling",
-            main_category="Video Generation",
             description="Kling Lip Sync Audio to Video Node. Syncs mouth movements in a video file to the audio content of an audio file. When using, ensure that the audio contains clearly distinguishable vocals and that the video contains a distinct face. The audio file should not be larger than 5MB. The video file should not be larger than 100MB, should have height/width between 720px and 1920px, and should be between 2s and 10s in length.",
             inputs=[
                 IO.Video.Input("video"),
@@ -2008,6 +2007,7 @@ class KlingLipSyncTextToVideoNode(IO.ComfyNode):
                     max=2.0,
                     display_mode=IO.NumberDisplay.slider,
                     tooltip="Speech Rate. Valid range: 0.8~2.0, accurate to one decimal place.",
+                    advanced=True,
                 ),
             ],
             outputs=[
@@ -2129,6 +2129,7 @@ class KlingImageGenerationNode(IO.ComfyNode):
                 IO.Combo.Input(
                     "image_type",
                     options=[i.value for i in KlingImageGenImageReferenceType],
+                    advanced=True,
                 ),
                 IO.Float.Input(
                     "image_fidelity",
@@ -2138,6 +2139,7 @@ class KlingImageGenerationNode(IO.ComfyNode):
                     step=0.01,
                     display_mode=IO.NumberDisplay.slider,
                     tooltip="Reference intensity for user-uploaded images",
+                    advanced=True,
                 ),
                 IO.Float.Input(
                     "human_fidelity",
@@ -2147,6 +2149,7 @@ class KlingImageGenerationNode(IO.ComfyNode):
                     step=0.01,
                     display_mode=IO.NumberDisplay.slider,
                     tooltip="Subject reference similarity",
+                    advanced=True,
                 ),
                 IO.Combo.Input(
                     "model_name",
@@ -2261,7 +2264,7 @@ class TextToVideoWithAudio(IO.ComfyNode):
                 IO.Combo.Input("mode", options=["pro"]),
                 IO.Combo.Input("aspect_ratio", options=["16:9", "9:16", "1:1"]),
                 IO.Combo.Input("duration", options=[5, 10]),
-                IO.Boolean.Input("generate_audio", default=True),
+                IO.Boolean.Input("generate_audio", default=True, advanced=True),
             ],
             outputs=[
                 IO.Video.Output(),
@@ -2329,7 +2332,7 @@ class ImageToVideoWithAudio(IO.ComfyNode):
                 IO.String.Input("prompt", multiline=True, tooltip="Positive text prompt."),
                 IO.Combo.Input("mode", options=["pro"]),
                 IO.Combo.Input("duration", options=[5, 10]),
-                IO.Boolean.Input("generate_audio", default=True),
+                IO.Boolean.Input("generate_audio", default=True, advanced=True),
             ],
             outputs=[
                 IO.Video.Output(),

comfy_api_nodes/nodes_ltxv.py

@@ -74,6 +74,7 @@ class TextToVideoNode(IO.ComfyNode):
                     default=False,
                     optional=True,
                     tooltip="When true, the generated video will include AI-generated audio matching the scene.",
+                    advanced=True,
                 ),
             ],
             outputs=[
@@ -151,6 +152,7 @@ class ImageToVideoNode(IO.ComfyNode):
                     default=False,
                     optional=True,
                     tooltip="When true, the generated video will include AI-generated audio matching the scene.",
+                    advanced=True,
                 ),
             ],
             outputs=[

comfy_api_nodes/nodes_magnific.py

@@ -86,11 +86,13 @@ class MagnificImageUpscalerCreativeNode(IO.ComfyNode):
                 IO.Combo.Input(
                     "engine",
                     options=["automatic", "magnific_illusio", "magnific_sharpy", "magnific_sparkle"],
+                    advanced=True,
                 ),
                 IO.Boolean.Input(
                     "auto_downscale",
                     default=False,
                     tooltip="Automatically downscale input image if output would exceed maximum pixel limit.",
+                    advanced=True,
                 ),
             ],
             outputs=[
@@ -242,6 +244,7 @@ class MagnificImageUpscalerPreciseV2Node(IO.ComfyNode):
                     "auto_downscale",
                     default=False,
                     tooltip="Automatically downscale input image if output would exceed maximum resolution.",
+                    advanced=True,
                 ),
             ],
             outputs=[
@@ -392,6 +395,7 @@ class MagnificImageStyleTransferNode(IO.ComfyNode):
                         "softy",
                     ],
                     tooltip="Processing engine selection.",
+                    advanced=True,
                 ),
                 IO.DynamicCombo.Input(
                     "portrait_mode",
@@ -420,6 +424,7 @@ class MagnificImageStyleTransferNode(IO.ComfyNode):
                     default=True,
                     tooltip="When disabled, expect each generation to introduce a degree of randomness, "
                     "leading to more diverse outcomes.",
+                    advanced=True,
                 ),
             ],
             outputs=[
@@ -534,16 +539,19 @@ class MagnificImageRelightNode(IO.ComfyNode):
                     "interpolate_from_original",
                     default=False,
                     tooltip="Restricts generation freedom to match original more closely.",
+                    advanced=True,
                 ),
                 IO.Boolean.Input(
                     "change_background",
                     default=True,
                     tooltip="Modifies background based on prompt/reference.",
+                    advanced=True,
                 ),
                 IO.Boolean.Input(
                     "preserve_details",
                     default=True,
                     tooltip="Maintains texture and fine details from original.",
+                    advanced=True,
                 ),
                 IO.DynamicCombo.Input(
                     "advanced_settings",

comfy_api_nodes/nodes_meshy.py

@@ -58,11 +58,12 @@ class MeshyTextToModelNode(IO.ComfyNode):
                     ],
                     tooltip="When set to false, returns an unprocessed triangular mesh.",
                 ),
-                IO.Combo.Input("symmetry_mode", options=["auto", "on", "off"]),
+                IO.Combo.Input("symmetry_mode", options=["auto", "on", "off"], advanced=True),
                 IO.Combo.Input(
                     "pose_mode",
                     options=["", "A-pose", "T-pose"],
                     tooltip="Specify the pose mode for the generated model.",
+                    advanced=True,
                 ),
                 IO.Int.Input(
                     "seed",
@@ -155,6 +156,7 @@ class MeshyRefineNode(IO.ComfyNode):
                     tooltip="Generate PBR Maps (metallic, roughness, normal) in addition to the base color. "
                     "Note: this should be set to false when using Sculpture style, "
                     "as Sculpture style generates its own set of PBR maps.",
+                    advanced=True,
                 ),
                 IO.String.Input(
                     "texture_prompt",
@@ -299,6 +301,7 @@ class MeshyImageToModelNode(IO.ComfyNode):
                     "pose_mode",
                     options=["", "A-pose", "T-pose"],
                     tooltip="Specify the pose mode for the generated model.",
+                    advanced=True,
                 ),
                 IO.Int.Input(
                     "seed",
@@ -429,7 +432,7 @@ class MeshyMultiImageToModelNode(IO.ComfyNode):
                     ],
                     tooltip="When set to false, returns an unprocessed triangular mesh.",
                 ),
-                IO.Combo.Input("symmetry_mode", options=["auto", "on", "off"]),
+                IO.Combo.Input("symmetry_mode", options=["auto", "on", "off"], advanced=True),
                 IO.DynamicCombo.Input(
                     "should_texture",
                     options=[
@@ -466,6 +469,7 @@ class MeshyMultiImageToModelNode(IO.ComfyNode):
                     "pose_mode",
                     options=["", "A-pose", "T-pose"],
                     tooltip="Specify the pose mode for the generated model.",
+                    advanced=True,
                 ),
                 IO.Int.Input(
                     "seed",
@@ -728,8 +732,9 @@ class MeshyTextureNode(IO.ComfyNode):
                     tooltip="Use the original UV of the model instead of generating new UVs. "
                     "When enabled, Meshy preserves existing textures from the uploaded model. "
                     "If the model has no original UV, the quality of the output might not be as good.",
+                    advanced=True,
                 ),
-                IO.Boolean.Input("pbr", default=False),
+                IO.Boolean.Input("pbr", default=False, advanced=True),
                 IO.String.Input(
                     "text_style_prompt",
                     default="",

comfy_api_nodes/nodes_openai.py

@@ -576,7 +576,6 @@ class OpenAIChatNode(IO.ComfyNode):
             node_id="OpenAIChatNode",
             display_name="OpenAI ChatGPT",
             category="api node/text/OpenAI",
-            main_category="Text Generation",
             description="Generate text responses from an OpenAI model.",
             inputs=[
                 IO.String.Input(
@@ -589,6 +588,7 @@ class OpenAIChatNode(IO.ComfyNode):
                     "persist_context",
                     default=False,
                     tooltip="This parameter is deprecated and has no effect.",
+                    advanced=True,
                 ),
                 IO.Combo.Input(
                     "model",
@@ -863,6 +863,7 @@ class OpenAIChatConfig(IO.ComfyNode):
                     options=["auto", "disabled"],
                     default="auto",
                     tooltip="The truncation strategy to use for the model response. auto: If the context of this response and previous ones exceeds the model's context window size, the model will truncate the response to fit the context window by dropping input items in the middle of the conversation.disabled: If a model response will exceed the context window size for a model, the request will fail with a 400 error",
+                    advanced=True,
                 ),
                 IO.Int.Input(
                     "max_output_tokens",
@@ -871,6 +872,7 @@ class OpenAIChatConfig(IO.ComfyNode):
                     max=16384,
                     tooltip="An upper bound for the number of tokens that can be generated for a response, including visible output tokens",
                     optional=True,
+                    advanced=True,
                 ),
                 IO.String.Input(
                     "instructions",

comfy_api_nodes/nodes_recraft.py

@@ -963,7 +963,6 @@ class RecraftRemoveBackgroundNode(IO.ComfyNode):
             node_id="RecraftRemoveBackgroundNode",
             display_name="Recraft Remove Background",
             category="api node/image/Recraft",
-            main_category="Image Tools",
             description="Remove background from image, and return processed image and mask.",
             inputs=[
                 IO.Image.Input("image"),

comfy_api_nodes/nodes_rodin.py

@@ -493,7 +493,7 @@ class Rodin3D_Gen2(IO.ComfyNode):
                     default="500K-Triangle",
                     optional=True,
                 ),
-                IO.Boolean.Input("TAPose", default=False),
+                IO.Boolean.Input("TAPose", default=False, advanced=True),
             ],
             outputs=[
                 IO.String.Output(display_name="3D Model Path"),  # for backward compatibility only

comfy_api_nodes/nodes_stability.py

@@ -86,6 +86,7 @@ class StabilityStableImageUltraNode(IO.ComfyNode):
                     "style_preset",
                     options=get_stability_style_presets(),
                     tooltip="Optional desired style of generated image.",
+                    advanced=True,
                 ),
                 IO.Int.Input(
                     "seed",
@@ -107,6 +108,7 @@ class StabilityStableImageUltraNode(IO.ComfyNode):
                     tooltip="A blurb of text describing what you do not wish to see in the output image. This is an advanced feature.",
                     force_input=True,
                     optional=True,
+                    advanced=True,
                 ),
                 IO.Float.Input(
                     "image_denoise",
@@ -218,6 +220,7 @@ class StabilityStableImageSD_3_5Node(IO.ComfyNode):
                     "style_preset",
                     options=get_stability_style_presets(),
                     tooltip="Optional desired style of generated image.",
+                    advanced=True,
                 ),
                 IO.Float.Input(
                     "cfg_scale",
@@ -247,6 +250,7 @@ class StabilityStableImageSD_3_5Node(IO.ComfyNode):
                     tooltip="Keywords of what you do not wish to see in the output image. This is an advanced feature.",
                     force_input=True,
                     optional=True,
+                    advanced=True,
                 ),
                 IO.Float.Input(
                     "image_denoise",
@@ -384,6 +388,7 @@ class StabilityUpscaleConservativeNode(IO.ComfyNode):
                     tooltip="Keywords of what you do not wish to see in the output image. This is an advanced feature.",
                     force_input=True,
                     optional=True,
+                    advanced=True,
                 ),
             ],
             outputs=[
@@ -474,6 +479,7 @@ class StabilityUpscaleCreativeNode(IO.ComfyNode):
                     "style_preset",
                     options=get_stability_style_presets(),
                     tooltip="Optional desired style of generated image.",
+                    advanced=True,
                 ),
                 IO.Int.Input(
                     "seed",
@@ -491,6 +497,7 @@ class StabilityUpscaleCreativeNode(IO.ComfyNode):
                     tooltip="Keywords of what you do not wish to see in the output image. This is an advanced feature.",
                     force_input=True,
                     optional=True,
+                    advanced=True,
                 ),
             ],
             outputs=[
@@ -624,7 +631,6 @@ class StabilityTextToAudio(IO.ComfyNode):
             node_id="StabilityTextToAudio",
             display_name="Stability AI Text To Audio",
             category="api node/audio/Stability AI",
-            main_category="Audio",
             description=cleandoc(cls.__doc__ or ""),
             inputs=[
                 IO.Combo.Input(
@@ -660,6 +666,7 @@ class StabilityTextToAudio(IO.ComfyNode):
                     step=1,
                     tooltip="Controls the number of sampling steps.",
                     optional=True,
+                    advanced=True,
                 ),
             ],
             outputs=[
@@ -737,6 +744,7 @@ class StabilityAudioToAudio(IO.ComfyNode):
                     step=1,
                     tooltip="Controls the number of sampling steps.",
                     optional=True,
+                    advanced=True,
                 ),
                 IO.Float.Input(
                     "strength",
@@ -830,6 +838,7 @@ class StabilityAudioInpaint(IO.ComfyNode):
                     step=1,
                     tooltip="Controls the number of sampling steps.",
                     optional=True,
+                    advanced=True,
                 ),
                 IO.Int.Input(
                     "mask_start",
@@ -838,6 +847,7 @@ class StabilityAudioInpaint(IO.ComfyNode):
                     max=190,
                     step=1,
                     optional=True,
+                    advanced=True,
                 ),
                 IO.Int.Input(
                     "mask_end",
@@ -846,6 +856,7 @@ class StabilityAudioInpaint(IO.ComfyNode):
                     max=190,
                     step=1,
                     optional=True,
+                    advanced=True,
                 ),
             ],
             outputs=[

comfy_api_nodes/nodes_topaz.py

@@ -63,12 +63,14 @@ class TopazImageEnhance(IO.ComfyNode):
                     "subject_detection",
                     options=["All", "Foreground", "Background"],
                     optional=True,
+                    advanced=True,
                 ),
                 IO.Boolean.Input(
                     "face_enhancement",
                     default=True,
                     optional=True,
                     tooltip="Enhance faces (if present) during processing.",
+                    advanced=True,
                 ),
                 IO.Float.Input(
                     "face_enhancement_creativity",
@@ -79,6 +81,7 @@ class TopazImageEnhance(IO.ComfyNode):
                     display_mode=IO.NumberDisplay.number,
                     optional=True,
                     tooltip="Set the creativity level for face enhancement.",
+                    advanced=True,
                 ),
                 IO.Float.Input(
                     "face_enhancement_strength",
@@ -89,6 +92,7 @@ class TopazImageEnhance(IO.ComfyNode):
                     display_mode=IO.NumberDisplay.number,
                     optional=True,
                     tooltip="Controls how sharp enhanced faces are relative to the background.",
+                    advanced=True,
                 ),
                 IO.Boolean.Input(
                     "crop_to_fill",
@@ -96,6 +100,7 @@ class TopazImageEnhance(IO.ComfyNode):
                     optional=True,
                     tooltip="By default, the image is letterboxed when the output aspect ratio differs. "
                     "Enable to crop the image to fill the output dimensions.",
+                    advanced=True,
                 ),
                 IO.Int.Input(
                     "output_width",
@@ -106,6 +111,7 @@ class TopazImageEnhance(IO.ComfyNode):
                     display_mode=IO.NumberDisplay.number,
                     optional=True,
                     tooltip="Zero value means to calculate automatically (usually it will be original size or output_height if specified).",
+                    advanced=True,
                 ),
                 IO.Int.Input(
                     "output_height",
@@ -116,6 +122,7 @@ class TopazImageEnhance(IO.ComfyNode):
                     display_mode=IO.NumberDisplay.number,
                     optional=True,
                     tooltip="Zero value means to output in the same height as original or output width.",
+                    advanced=True,
                 ),
                 IO.Int.Input(
                     "creativity",
@@ -131,12 +138,14 @@ class TopazImageEnhance(IO.ComfyNode):
                     default=True,
                     optional=True,
                     tooltip="Preserve subjects' facial identity.",
+                    advanced=True,
                 ),
                 IO.Boolean.Input(
                     "color_preservation",
                     default=True,
                     optional=True,
                     tooltip="Preserve the original colors.",
+                    advanced=True,
                 ),
             ],
             outputs=[
@@ -234,9 +243,10 @@ class TopazVideoEnhance(IO.ComfyNode):
                     default="low",
                     tooltip="Creativity level (applies only to Starlight (Astra) Creative).",
                     optional=True,
+                    advanced=True,
                 ),
                 IO.Boolean.Input("interpolation_enabled", default=False, optional=True),
-                IO.Combo.Input("interpolation_model", options=["apo-8"], default="apo-8", optional=True),
+                IO.Combo.Input("interpolation_model", options=["apo-8"], default="apo-8", optional=True, advanced=True),
                 IO.Int.Input(
                     "interpolation_slowmo",
                     default=1,
@@ -246,6 +256,7 @@ class TopazVideoEnhance(IO.ComfyNode):
                     tooltip="Slow-motion factor applied to the input video. "
                     "For example, 2 makes the output twice as slow and doubles the duration.",
                     optional=True,
+                    advanced=True,
                 ),
                 IO.Int.Input(
                     "interpolation_frame_rate",
@@ -261,6 +272,7 @@ class TopazVideoEnhance(IO.ComfyNode):
                     default=False,
                     tooltip="Analyze the input for duplicate frames and remove them.",
                     optional=True,
+                    advanced=True,
                 ),
                 IO.Float.Input(
                     "interpolation_duplicate_threshold",
@@ -271,6 +283,7 @@ class TopazVideoEnhance(IO.ComfyNode):
                     display_mode=IO.NumberDisplay.number,
                     tooltip="Detection sensitivity for duplicate frames.",
                     optional=True,
+                    advanced=True,
                 ),
                 IO.Combo.Input(
                     "dynamic_compression_level",
@@ -278,6 +291,7 @@ class TopazVideoEnhance(IO.ComfyNode):
                     default="Low",
                     tooltip="CQP level.",
                     optional=True,
+                    advanced=True,
                 ),
             ],
             outputs=[

comfy_api_nodes/nodes_tripo.py

@@ -89,13 +89,13 @@ class TripoTextToModelNode(IO.ComfyNode):
                 IO.Combo.Input("style", options=TripoStyle, default="None", optional=True),
                 IO.Boolean.Input("texture", default=True, optional=True),
                 IO.Boolean.Input("pbr", default=True, optional=True),
-                IO.Int.Input("image_seed", default=42, optional=True),
-                IO.Int.Input("model_seed", default=42, optional=True),
-                IO.Int.Input("texture_seed", default=42, optional=True),
-                IO.Combo.Input("texture_quality", default="standard", options=["standard", "detailed"], optional=True),
-                IO.Int.Input("face_limit", default=-1, min=-1, max=2000000, optional=True),
-                IO.Boolean.Input("quad", default=False, optional=True),
-                IO.Combo.Input("geometry_quality", default="standard", options=["standard", "detailed"], optional=True),
+                IO.Int.Input("image_seed", default=42, optional=True, advanced=True),
+                IO.Int.Input("model_seed", default=42, optional=True, advanced=True),
+                IO.Int.Input("texture_seed", default=42, optional=True, advanced=True),
+                IO.Combo.Input("texture_quality", default="standard", options=["standard", "detailed"], optional=True, advanced=True),
+                IO.Int.Input("face_limit", default=-1, min=-1, max=2000000, optional=True, advanced=True),
+                IO.Boolean.Input("quad", default=False, optional=True, advanced=True),
+                IO.Combo.Input("geometry_quality", default="standard", options=["standard", "detailed"], optional=True, advanced=True),
             ],
             outputs=[
                 IO.String.Output(display_name="model_file"),  # for backward compatibility only
@@ -210,18 +210,18 @@ class TripoImageToModelNode(IO.ComfyNode):
                 IO.Combo.Input("style", options=TripoStyle, default="None", optional=True),
                 IO.Boolean.Input("texture", default=True, optional=True),
                 IO.Boolean.Input("pbr", default=True, optional=True),
-                IO.Int.Input("model_seed", default=42, optional=True),
+                IO.Int.Input("model_seed", default=42, optional=True, advanced=True),
                 IO.Combo.Input(
-                    "orientation", options=TripoOrientation, default=TripoOrientation.DEFAULT, optional=True
+                    "orientation", options=TripoOrientation, default=TripoOrientation.DEFAULT, optional=True, advanced=True
                 ),
-                IO.Int.Input("texture_seed", default=42, optional=True),
-                IO.Combo.Input("texture_quality", default="standard", options=["standard", "detailed"], optional=True),
+                IO.Int.Input("texture_seed", default=42, optional=True, advanced=True),
+                IO.Combo.Input("texture_quality", default="standard", options=["standard", "detailed"], optional=True, advanced=True),
                 IO.Combo.Input(
-                    "texture_alignment", default="original_image", options=["original_image", "geometry"], optional=True
+                    "texture_alignment", default="original_image", options=["original_image", "geometry"], optional=True, advanced=True
                 ),
-                IO.Int.Input("face_limit", default=-1, min=-1, max=500000, optional=True),
-                IO.Boolean.Input("quad", default=False, optional=True),
-                IO.Combo.Input("geometry_quality", default="standard", options=["standard", "detailed"], optional=True),
+                IO.Int.Input("face_limit", default=-1, min=-1, max=500000, optional=True, advanced=True),
+                IO.Boolean.Input("quad", default=False, optional=True, advanced=True),
+                IO.Combo.Input("geometry_quality", default="standard", options=["standard", "detailed"], optional=True, advanced=True),
             ],
             outputs=[
                 IO.String.Output(display_name="model_file"),  # for backward compatibility only
@@ -347,18 +347,19 @@ class TripoMultiviewToModelNode(IO.ComfyNode):
                     options=TripoOrientation,
                     default=TripoOrientation.DEFAULT,
                     optional=True,
+                    advanced=True,
                 ),
                 IO.Boolean.Input("texture", default=True, optional=True),
                 IO.Boolean.Input("pbr", default=True, optional=True),
-                IO.Int.Input("model_seed", default=42, optional=True),
-                IO.Int.Input("texture_seed", default=42, optional=True),
-                IO.Combo.Input("texture_quality", default="standard", options=["standard", "detailed"], optional=True),
+                IO.Int.Input("model_seed", default=42, optional=True, advanced=True),
+                IO.Int.Input("texture_seed", default=42, optional=True, advanced=True),
+                IO.Combo.Input("texture_quality", default="standard", options=["standard", "detailed"], optional=True, advanced=True),
                 IO.Combo.Input(
-                    "texture_alignment", default="original_image", options=["original_image", "geometry"], optional=True
+                    "texture_alignment", default="original_image", options=["original_image", "geometry"], optional=True, advanced=True
                 ),
-                IO.Int.Input("face_limit", default=-1, min=-1, max=500000, optional=True),
-                IO.Boolean.Input("quad", default=False, optional=True),
-                IO.Combo.Input("geometry_quality", default="standard", options=["standard", "detailed"], optional=True),
+                IO.Int.Input("face_limit", default=-1, min=-1, max=500000, optional=True, advanced=True),
+                IO.Boolean.Input("quad", default=False, optional=True, advanced=True),
+                IO.Combo.Input("geometry_quality", default="standard", options=["standard", "detailed"], optional=True, advanced=True),
             ],
             outputs=[
                 IO.String.Output(display_name="model_file"),  # for backward compatibility only
@@ -474,10 +475,10 @@ class TripoTextureNode(IO.ComfyNode):
                 IO.Custom("MODEL_TASK_ID").Input("model_task_id"),
                 IO.Boolean.Input("texture", default=True, optional=True),
                 IO.Boolean.Input("pbr", default=True, optional=True),
-                IO.Int.Input("texture_seed", default=42, optional=True),
-                IO.Combo.Input("texture_quality", default="standard", options=["standard", "detailed"], optional=True),
+                IO.Int.Input("texture_seed", default=42, optional=True, advanced=True),
+                IO.Combo.Input("texture_quality", default="standard", options=["standard", "detailed"], optional=True, advanced=True),
                 IO.Combo.Input(
-                    "texture_alignment", default="original_image", options=["original_image", "geometry"], optional=True
+                    "texture_alignment", default="original_image", options=["original_image", "geometry"], optional=True, advanced=True
                 ),
             ],
             outputs=[
@@ -682,13 +683,14 @@ class TripoConversionNode(IO.ComfyNode):
             inputs=[
                 IO.Custom("MODEL_TASK_ID,RIG_TASK_ID,RETARGET_TASK_ID").Input("original_model_task_id"),
                 IO.Combo.Input("format", options=["GLTF", "USDZ", "FBX", "OBJ", "STL", "3MF"]),
-                IO.Boolean.Input("quad", default=False, optional=True),
+                IO.Boolean.Input("quad", default=False, optional=True, advanced=True),
                 IO.Int.Input(
                     "face_limit",
                     default=-1,
                     min=-1,
                     max=2000000,
                     optional=True,
+                    advanced=True,
                 ),
                 IO.Int.Input(
                     "texture_size",
@@ -696,47 +698,53 @@ class TripoConversionNode(IO.ComfyNode):
                     min=128,
                     max=4096,
                     optional=True,
+                    advanced=True,
                 ),
                 IO.Combo.Input(
                     "texture_format",
                     options=["BMP", "DPX", "HDR", "JPEG", "OPEN_EXR", "PNG", "TARGA", "TIFF", "WEBP"],
                     default="JPEG",
                     optional=True,
+                    advanced=True,
                 ),
-                IO.Boolean.Input("force_symmetry", default=False, optional=True),
-                IO.Boolean.Input("flatten_bottom", default=False, optional=True),
+                IO.Boolean.Input("force_symmetry", default=False, optional=True, advanced=True),
+                IO.Boolean.Input("flatten_bottom", default=False, optional=True, advanced=True),
                 IO.Float.Input(
                     "flatten_bottom_threshold",
                     default=0.0,
                     min=0.0,
                     max=1.0,
                     optional=True,
+                    advanced=True,
                 ),
-                IO.Boolean.Input("pivot_to_center_bottom", default=False, optional=True),
+                IO.Boolean.Input("pivot_to_center_bottom", default=False, optional=True, advanced=True),
                 IO.Float.Input(
                     "scale_factor",
                     default=1.0,
                     min=0.0,
                     optional=True,
+                    advanced=True,
                 ),
-                IO.Boolean.Input("with_animation", default=False, optional=True),
-                IO.Boolean.Input("pack_uv", default=False, optional=True),
-                IO.Boolean.Input("bake", default=False, optional=True),
-                IO.String.Input("part_names", default="", optional=True),  # comma-separated list
+                IO.Boolean.Input("with_animation", default=False, optional=True, advanced=True),
+                IO.Boolean.Input("pack_uv", default=False, optional=True, advanced=True),
+                IO.Boolean.Input("bake", default=False, optional=True, advanced=True),
+                IO.String.Input("part_names", default="", optional=True, advanced=True),  # comma-separated list
                 IO.Combo.Input(
                     "fbx_preset",
                     options=["blender", "mixamo", "3dsmax"],
                     default="blender",
                     optional=True,
+                    advanced=True,
                 ),
-                IO.Boolean.Input("export_vertex_colors", default=False, optional=True),
+                IO.Boolean.Input("export_vertex_colors", default=False, optional=True, advanced=True),
                 IO.Combo.Input(
                     "export_orientation",
                     options=["align_image", "default"],
                     default="default",
                     optional=True,
+                    advanced=True,
                 ),
-                IO.Boolean.Input("animate_in_place", default=False, optional=True),
+                IO.Boolean.Input("animate_in_place", default=False, optional=True, advanced=True),
             ],
             outputs=[],
             hidden=[

comfy_api_nodes/nodes_veo2.py

@@ -81,6 +81,7 @@ class VeoVideoGenerationNode(IO.ComfyNode):
                     default=True,
                     tooltip="Whether to enhance the prompt with AI assistance",
                     optional=True,
+                    advanced=True,
                 ),
                 IO.Combo.Input(
                     "person_generation",
@@ -88,6 +89,7 @@ class VeoVideoGenerationNode(IO.ComfyNode):
                     default="ALLOW",
                     tooltip="Whether to allow generating people in the video",
                     optional=True,
+                    advanced=True,
                 ),
                 IO.Int.Input(
                     "seed",
@@ -299,6 +301,7 @@ class Veo3VideoGenerationNode(VeoVideoGenerationNode):
                     default=True,
                     tooltip="This parameter is deprecated and ignored.",
                     optional=True,
+                    advanced=True,
                 ),
                 IO.Combo.Input(
                     "person_generation",
@@ -306,6 +309,7 @@ class Veo3VideoGenerationNode(VeoVideoGenerationNode):
                     default="ALLOW",
                     tooltip="Whether to allow generating people in the video",
                     optional=True,
+                    advanced=True,
                 ),
                 IO.Int.Input(
                     "seed",

comfy_api_nodes/nodes_vidu.py

@@ -111,12 +111,14 @@ class ViduTextToVideoNode(IO.ComfyNode):
                     options=["1080p"],
                     tooltip="Supported values may vary by model & duration",
                     optional=True,
+                    advanced=True,
                 ),
                 IO.Combo.Input(
                     "movement_amplitude",
                     options=["auto", "small", "medium", "large"],
                     tooltip="The movement amplitude of objects in the frame",
                     optional=True,
+                    advanced=True,
                 ),
             ],
             outputs=[
@@ -207,12 +209,14 @@ class ViduImageToVideoNode(IO.ComfyNode):
                     options=["1080p"],
                     tooltip="Supported values may vary by model & duration",
                     optional=True,
+                    advanced=True,
                 ),
                 IO.Combo.Input(
                     "movement_amplitude",
                     options=["auto", "small", "medium", "large"],
                     tooltip="The movement amplitude of objects in the frame",
                     optional=True,
+                    advanced=True,
                 ),
             ],
             outputs=[
@@ -313,12 +317,14 @@ class ViduReferenceVideoNode(IO.ComfyNode):
                     options=["1080p"],
                     tooltip="Supported values may vary by model & duration",
                     optional=True,
+                    advanced=True,
                 ),
                 IO.Combo.Input(
                     "movement_amplitude",
                     options=["auto", "small", "medium", "large"],
                     tooltip="The movement amplitude of objects in the frame",
                     optional=True,
+                    advanced=True,
                 ),
             ],
             outputs=[
@@ -425,12 +431,14 @@ class ViduStartEndToVideoNode(IO.ComfyNode):
                     options=["1080p"],
                     tooltip="Supported values may vary by model & duration",
                     optional=True,
+                    advanced=True,
                 ),
                 IO.Combo.Input(
                     "movement_amplitude",
                     options=["auto", "small", "medium", "large"],
                     tooltip="The movement amplitude of objects in the frame",
                     optional=True,
+                    advanced=True,
                 ),
             ],
             outputs=[
@@ -510,11 +518,12 @@ class Vidu2TextToVideoNode(IO.ComfyNode):
                     control_after_generate=True,
                 ),
                 IO.Combo.Input("aspect_ratio", options=["16:9", "9:16", "3:4", "4:3", "1:1"]),
-                IO.Combo.Input("resolution", options=["720p", "1080p"]),
+                IO.Combo.Input("resolution", options=["720p", "1080p"], advanced=True),
                 IO.Boolean.Input(
                     "background_music",
                     default=False,
                     tooltip="Whether to add background music to the generated video.",
+                    advanced=True,
                 ),
             ],
             outputs=[
@@ -608,11 +617,13 @@ class Vidu2ImageToVideoNode(IO.ComfyNode):
                 IO.Combo.Input(
                     "resolution",
                     options=["720p", "1080p"],
+                    advanced=True,
                 ),
                 IO.Combo.Input(
                     "movement_amplitude",
                     options=["auto", "small", "medium", "large"],
                     tooltip="The movement amplitude of objects in the frame.",
+                    advanced=True,
                 ),
             ],
             outputs=[
@@ -726,6 +737,7 @@ class Vidu2ReferenceVideoNode(IO.ComfyNode):
                     "audio",
                     default=False,
                     tooltip="When enabled video will contain generated speech and background music based on the prompt.",
+                    advanced=True,
                 ),
                 IO.Int.Input(
                     "duration",
@@ -745,11 +757,12 @@ class Vidu2ReferenceVideoNode(IO.ComfyNode):
                     control_after_generate=True,
                 ),
                 IO.Combo.Input("aspect_ratio", options=["16:9", "9:16", "4:3", "3:4", "1:1"]),
-                IO.Combo.Input("resolution", options=["720p", "1080p"]),
+                IO.Combo.Input("resolution", options=["720p", "1080p"], advanced=True),
                 IO.Combo.Input(
                     "movement_amplitude",
                     options=["auto", "small", "medium", "large"],
                     tooltip="The movement amplitude of objects in the frame.",
+                    advanced=True,
                 ),
             ],
             outputs=[
@@ -863,11 +876,12 @@ class Vidu2StartEndToVideoNode(IO.ComfyNode):
                     display_mode=IO.NumberDisplay.number,
                     control_after_generate=True,
                 ),
-                IO.Combo.Input("resolution", options=["720p", "1080p"]),
+                IO.Combo.Input("resolution", options=["720p", "1080p"], advanced=True),
                 IO.Combo.Input(
                     "movement_amplitude",
                     options=["auto", "small", "medium", "large"],
                     tooltip="The movement amplitude of objects in the frame.",
+                    advanced=True,
                 ),
             ],
             outputs=[

comfy_api_nodes/nodes_wan.py

@@ -227,12 +227,14 @@ class WanTextToImageApi(IO.ComfyNode):
                     default=True,
                     tooltip="Whether to enhance the prompt with AI assistance.",
                     optional=True,
+                    advanced=True,
                 ),
                 IO.Boolean.Input(
                     "watermark",
                     default=False,
                     tooltip="Whether to add an AI-generated watermark to the result.",
                     optional=True,
+                    advanced=True,
                 ),
             ],
             outputs=[
@@ -355,6 +357,7 @@ class WanImageToImageApi(IO.ComfyNode):
                     default=False,
                     tooltip="Whether to add an AI-generated watermark to the result.",
                     optional=True,
+                    advanced=True,
                 ),
             ],
             outputs=[
@@ -495,18 +498,21 @@ class WanTextToVideoApi(IO.ComfyNode):
                     default=False,
                     optional=True,
                     tooltip="If no audio input is provided, generate audio automatically.",
+                    advanced=True,
                 ),
                 IO.Boolean.Input(
                     "prompt_extend",
                     default=True,
                     tooltip="Whether to enhance the prompt with AI assistance.",
                     optional=True,
+                    advanced=True,
                 ),
                 IO.Boolean.Input(
                     "watermark",
                     default=False,
                     tooltip="Whether to add an AI-generated watermark to the result.",
                     optional=True,
+                    advanced=True,
                 ),
                 IO.Combo.Input(
                     "shot_type",
@@ -515,6 +521,7 @@ class WanTextToVideoApi(IO.ComfyNode):
                     "single continuous shot or multiple shots with cuts. "
                     "This parameter takes effect only when prompt_extend is True.",
                     optional=True,
+                    advanced=True,
                 ),
             ],
             outputs=[
@@ -667,18 +674,21 @@ class WanImageToVideoApi(IO.ComfyNode):
                     default=False,
                     optional=True,
                     tooltip="If no audio input is provided, generate audio automatically.",
+                    advanced=True,
                 ),
                 IO.Boolean.Input(
                     "prompt_extend",
                     default=True,
                     tooltip="Whether to enhance the prompt with AI assistance.",
                     optional=True,
+                    advanced=True,
                 ),
                 IO.Boolean.Input(
                     "watermark",
                     default=False,
                     tooltip="Whether to add an AI-generated watermark to the result.",
                     optional=True,
+                    advanced=True,
                 ),
                 IO.Combo.Input(
                     "shot_type",
@@ -687,6 +697,7 @@ class WanImageToVideoApi(IO.ComfyNode):
                     "single continuous shot or multiple shots with cuts. "
                     "This parameter takes effect only when prompt_extend is True.",
                     optional=True,
+                    advanced=True,
                 ),
             ],
             outputs=[
@@ -839,11 +850,13 @@ class WanReferenceVideoApi(IO.ComfyNode):
                     options=["single", "multi"],
                     tooltip="Specifies the shot type for the generated video, that is, whether the video is a "
                     "single continuous shot or multiple shots with cuts.",
+                    advanced=True,
                 ),
                 IO.Boolean.Input(
                     "watermark",
                     default=False,
                     tooltip="Whether to add an AI-generated watermark to the result.",
+                    advanced=True,
                 ),
             ],
             outputs=[

comfy_extras/nodes_ace.py

@@ -44,13 +44,18 @@ class TextEncodeAceStepAudio15(io.ComfyNode):
                 io.Combo.Input("timesignature", options=['2', '3', '4', '6']),
                 io.Combo.Input("language", options=["en", "ja", "zh", "es", "de", "fr", "pt", "ru", "it", "nl", "pl", "tr", "vi", "cs", "fa", "id", "ko", "uk", "hu", "ar", "sv", "ro", "el"]),
                 io.Combo.Input("keyscale", options=[f"{root} {quality}" for quality in ["major", "minor"] for root in ["C", "C#", "Db", "D", "D#", "Eb", "E", "F", "F#", "Gb", "G", "G#", "Ab", "A", "A#", "Bb", "B"]]),
+                io.Boolean.Input("generate_audio_codes", default=True, tooltip="Enable the LLM that generates audio codes. This can be slow but will increase the quality of the generated audio. Turn this off if you are giving the model an audio reference.", advanced=True),
+                io.Float.Input("cfg_scale", default=2.0, min=0.0, max=100.0, step=0.1, advanced=True),
+                io.Float.Input("temperature", default=0.85, min=0.0, max=2.0, step=0.01, advanced=True),
+                io.Float.Input("top_p", default=0.9, min=0.0, max=2000.0, step=0.01, advanced=True),
+                io.Int.Input("top_k", default=0, min=0, max=100, advanced=True),
             ],
             outputs=[io.Conditioning.Output()],
         )
 
     @classmethod
-    def execute(cls, clip, tags, lyrics, seed, bpm, duration, timesignature, language, keyscale) -> io.NodeOutput:
-        tokens = clip.tokenize(tags, lyrics=lyrics, bpm=bpm, duration=duration, timesignature=int(timesignature), language=language, keyscale=keyscale, seed=seed)
+    def execute(cls, clip, tags, lyrics, seed, bpm, duration, timesignature, language, keyscale, generate_audio_codes, cfg_scale, temperature, top_p, top_k) -> io.NodeOutput:
+        tokens = clip.tokenize(tags, lyrics=lyrics, bpm=bpm, duration=duration, timesignature=int(timesignature), language=language, keyscale=keyscale, seed=seed, generate_audio_codes=generate_audio_codes, cfg_scale=cfg_scale, temperature=temperature, top_p=top_p, top_k=top_k)
         conditioning = clip.encode_from_tokens_scheduled(tokens)
         return io.NodeOutput(conditioning)
 
@@ -100,14 +105,15 @@ class EmptyAceStep15LatentAudio(io.ComfyNode):
         latent = torch.zeros([batch_size, 64, length], device=comfy.model_management.intermediate_device())
         return io.NodeOutput({"samples": latent, "type": "audio"})
 
-class ReferenceTimbreAudio(io.ComfyNode):
+class ReferenceAudio(io.ComfyNode):
     @classmethod
     def define_schema(cls):
         return io.Schema(
             node_id="ReferenceTimbreAudio",
+            display_name="Reference Audio",
             category="advanced/conditioning/audio",
             is_experimental=True,
-            description="This node sets the reference audio for timbre (for ace step 1.5)",
+            description="This node sets the reference audio for ace step 1.5",
             inputs=[
                 io.Conditioning.Input("conditioning"),
                 io.Latent.Input("latent", optional=True),
@@ -131,7 +137,7 @@ class AceExtension(ComfyExtension):
             EmptyAceStepLatentAudio,
             TextEncodeAceStepAudio15,
             EmptyAceStep15LatentAudio,
-            ReferenceTimbreAudio,
+            ReferenceAudio,
         ]
 
 async def comfy_entrypoint() -> AceExtension:

comfy_extras/nodes_advanced_samplers.py

@@ -47,8 +47,8 @@ class SamplerLCMUpscale(io.ComfyNode):
             node_id="SamplerLCMUpscale",
             category="sampling/custom_sampling/samplers",
             inputs=[
-                io.Float.Input("scale_ratio", default=1.0, min=0.1, max=20.0, step=0.01),
-                io.Int.Input("scale_steps", default=-1, min=-1, max=1000, step=1),
+                io.Float.Input("scale_ratio", default=1.0, min=0.1, max=20.0, step=0.01, advanced=True),
+                io.Int.Input("scale_steps", default=-1, min=-1, max=1000, step=1, advanced=True),
                 io.Combo.Input("upscale_method", options=cls.UPSCALE_METHODS),
             ],
             outputs=[io.Sampler.Output()],
@@ -94,7 +94,7 @@ class SamplerEulerCFGpp(io.ComfyNode):
             display_name="SamplerEulerCFG++",
             category="_for_testing",  # "sampling/custom_sampling/samplers"
             inputs=[
-                io.Combo.Input("version", options=["regular", "alternative"]),
+                io.Combo.Input("version", options=["regular", "alternative"], advanced=True),
             ],
             outputs=[io.Sampler.Output()],
             is_experimental=True,

comfy_extras/nodes_apg.py

@@ -26,6 +26,7 @@ class APG(io.ComfyNode):
                     max=10.0,
                     step=0.01,
                     tooltip="Controls the scale of the parallel guidance vector. Default CFG behavior at a setting of 1.",
+                    advanced=True,
                 ),
                 io.Float.Input(
                     "norm_threshold",
@@ -34,6 +35,7 @@ class APG(io.ComfyNode):
                     max=50.0,
                     step=0.1,
                     tooltip="Normalize guidance vector to this value, normalization disable at a setting of 0.",
+                    advanced=True,
                 ),
                 io.Float.Input(
                     "momentum",
@@ -42,6 +44,7 @@ class APG(io.ComfyNode):
                     max=1.0,
                     step=0.01,
                     tooltip="Controls a running average of guidance during diffusion, disabled at a setting of 0.",
+                    advanced=True,
                 ),
             ],
             outputs=[io.Model.Output()],

comfy_extras/nodes_attention_multiply.py

@@ -28,10 +28,10 @@ class UNetSelfAttentionMultiply(io.ComfyNode):
             category="_for_testing/attention_experiments",
             inputs=[
                 io.Model.Input("model"),
-                io.Float.Input("q", default=1.0, min=0.0, max=10.0, step=0.01),
-                io.Float.Input("k", default=1.0, min=0.0, max=10.0, step=0.01),
-                io.Float.Input("v", default=1.0, min=0.0, max=10.0, step=0.01),
-                io.Float.Input("out", default=1.0, min=0.0, max=10.0, step=0.01),
+                io.Float.Input("q", default=1.0, min=0.0, max=10.0, step=0.01, advanced=True),
+                io.Float.Input("k", default=1.0, min=0.0, max=10.0, step=0.01, advanced=True),
+                io.Float.Input("v", default=1.0, min=0.0, max=10.0, step=0.01, advanced=True),
+                io.Float.Input("out", default=1.0, min=0.0, max=10.0, step=0.01, advanced=True),
             ],
             outputs=[io.Model.Output()],
             is_experimental=True,
@@ -51,10 +51,10 @@ class UNetCrossAttentionMultiply(io.ComfyNode):
             category="_for_testing/attention_experiments",
             inputs=[
                 io.Model.Input("model"),
-                io.Float.Input("q", default=1.0, min=0.0, max=10.0, step=0.01),
-                io.Float.Input("k", default=1.0, min=0.0, max=10.0, step=0.01),
-                io.Float.Input("v", default=1.0, min=0.0, max=10.0, step=0.01),
-                io.Float.Input("out", default=1.0, min=0.0, max=10.0, step=0.01),
+                io.Float.Input("q", default=1.0, min=0.0, max=10.0, step=0.01, advanced=True),
+                io.Float.Input("k", default=1.0, min=0.0, max=10.0, step=0.01, advanced=True),
+                io.Float.Input("v", default=1.0, min=0.0, max=10.0, step=0.01, advanced=True),
+                io.Float.Input("out", default=1.0, min=0.0, max=10.0, step=0.01, advanced=True),
             ],
             outputs=[io.Model.Output()],
             is_experimental=True,
@@ -75,10 +75,10 @@ class CLIPAttentionMultiply(io.ComfyNode):
             category="_for_testing/attention_experiments",
             inputs=[
                 io.Clip.Input("clip"),
-                io.Float.Input("q", default=1.0, min=0.0, max=10.0, step=0.01),
-                io.Float.Input("k", default=1.0, min=0.0, max=10.0, step=0.01),
-                io.Float.Input("v", default=1.0, min=0.0, max=10.0, step=0.01),
-                io.Float.Input("out", default=1.0, min=0.0, max=10.0, step=0.01),
+                io.Float.Input("q", default=1.0, min=0.0, max=10.0, step=0.01, advanced=True),
+                io.Float.Input("k", default=1.0, min=0.0, max=10.0, step=0.01, advanced=True),
+                io.Float.Input("v", default=1.0, min=0.0, max=10.0, step=0.01, advanced=True),
+                io.Float.Input("out", default=1.0, min=0.0, max=10.0, step=0.01, advanced=True),
             ],
             outputs=[io.Clip.Output()],
             is_experimental=True,
@@ -109,10 +109,10 @@ class UNetTemporalAttentionMultiply(io.ComfyNode):
             category="_for_testing/attention_experiments",
             inputs=[
                 io.Model.Input("model"),
-                io.Float.Input("self_structural", default=1.0, min=0.0, max=10.0, step=0.01),
-                io.Float.Input("self_temporal", default=1.0, min=0.0, max=10.0, step=0.01),
-                io.Float.Input("cross_structural", default=1.0, min=0.0, max=10.0, step=0.01),
-                io.Float.Input("cross_temporal", default=1.0, min=0.0, max=10.0, step=0.01),
+                io.Float.Input("self_structural", default=1.0, min=0.0, max=10.0, step=0.01, advanced=True),
+                io.Float.Input("self_temporal", default=1.0, min=0.0, max=10.0, step=0.01, advanced=True),
+                io.Float.Input("cross_structural", default=1.0, min=0.0, max=10.0, step=0.01, advanced=True),
+                io.Float.Input("cross_temporal", default=1.0, min=0.0, max=10.0, step=0.01, advanced=True),
             ],
             outputs=[io.Model.Output()],
             is_experimental=True,

comfy_extras/nodes_audio.py

@@ -22,7 +22,7 @@ class EmptyLatentAudio(IO.ComfyNode):
             inputs=[
                 IO.Float.Input("seconds", default=47.6, min=1.0, max=1000.0, step=0.1),
                 IO.Int.Input(
-                    "batch_size", default=1, min=1, max=4096, tooltip="The number of latent images in the batch."
+                    "batch_size", default=1, min=1, max=4096, tooltip="The number of latent images in the batch.",
                 ),
             ],
             outputs=[IO.Latent.Output()],
@@ -94,6 +94,19 @@ class VAEEncodeAudio(IO.ComfyNode):
     encode = execute  # TODO: remove
 
 
+def vae_decode_audio(vae, samples, tile=None, overlap=None):
+    if tile is not None:
+        audio = vae.decode_tiled(samples["samples"], tile_y=tile, overlap=overlap).movedim(-1, 1)
+    else:
+        audio = vae.decode(samples["samples"]).movedim(-1, 1)
+
+    std = torch.std(audio, dim=[1, 2], keepdim=True) * 5.0
+    std[std < 1.0] = 1.0
+    audio /= std
+    vae_sample_rate = getattr(vae, "audio_sample_rate", 44100)
+    return {"waveform": audio, "sample_rate": vae_sample_rate if "sample_rate" not in samples else samples["sample_rate"]}
+
+
 class VAEDecodeAudio(IO.ComfyNode):
     @classmethod
     def define_schema(cls):
@@ -111,16 +124,33 @@ class VAEDecodeAudio(IO.ComfyNode):
 
     @classmethod
     def execute(cls, vae, samples) -> IO.NodeOutput:
-        audio = vae.decode(samples["samples"]).movedim(-1, 1)
-        std = torch.std(audio, dim=[1,2], keepdim=True) * 5.0
-        std[std < 1.0] = 1.0
-        audio /= std
-        vae_sample_rate = getattr(vae, "audio_sample_rate", 44100)
-        return IO.NodeOutput({"waveform": audio, "sample_rate": vae_sample_rate if "sample_rate" not in samples else samples["sample_rate"]})
+        return IO.NodeOutput(vae_decode_audio(vae, samples))
 
     decode = execute  # TODO: remove
 
 
+class VAEDecodeAudioTiled(IO.ComfyNode):
+    @classmethod
+    def define_schema(cls):
+        return IO.Schema(
+            node_id="VAEDecodeAudioTiled",
+            search_aliases=["latent to audio"],
+            display_name="VAE Decode Audio (Tiled)",
+            category="latent/audio",
+            inputs=[
+                IO.Latent.Input("samples"),
+                IO.Vae.Input("vae"),
+                IO.Int.Input("tile_size", default=512, min=32, max=8192, step=8),
+                IO.Int.Input("overlap", default=64, min=0, max=1024, step=8),
+            ],
+            outputs=[IO.Audio.Output()],
+        )
+
+    @classmethod
+    def execute(cls, vae, samples, tile_size, overlap) -> IO.NodeOutput:
+        return IO.NodeOutput(vae_decode_audio(vae, samples, tile_size, overlap))
+
+
 class SaveAudio(IO.ComfyNode):
     @classmethod
     def define_schema(cls):
@@ -129,7 +159,6 @@ class SaveAudio(IO.ComfyNode):
             search_aliases=["export flac"],
             display_name="Save Audio (FLAC)",
             category="audio",
-            main_category="Audio",
             inputs=[
                 IO.Audio.Input("audio"),
                 IO.String.Input("filename_prefix", default="audio/ComfyUI"),
@@ -271,7 +300,6 @@ class LoadAudio(IO.ComfyNode):
             search_aliases=["import audio", "open audio", "audio file"],
             display_name="Load Audio",
             category="audio",
-            main_category="Audio",
             inputs=[
                 IO.Combo.Input("audio", upload=IO.UploadType.audio, options=sorted(files)),
             ],
@@ -649,6 +677,7 @@ class EmptyAudio(IO.ComfyNode):
                     tooltip="Sample rate of the empty audio clip.",
                     min=1,
                     max=192000,
+                    advanced=True,
                 ),
                 IO.Int.Input(
                     "channels",
@@ -656,6 +685,7 @@ class EmptyAudio(IO.ComfyNode):
                     min=1,
                     max=2,
                     tooltip="Number of audio channels (1 for mono, 2 for stereo).",
+                    advanced=True,
                 ),
             ],
             outputs=[IO.Audio.Output()],
@@ -677,6 +707,7 @@ class AudioExtension(ComfyExtension):
             EmptyLatentAudio,
             VAEEncodeAudio,
             VAEDecodeAudio,
+            VAEDecodeAudioTiled,
             SaveAudio,
             SaveAudioMP3,
             SaveAudioOpus,

comfy_extras/nodes_camera_trajectory.py

@@ -174,10 +174,10 @@ class WanCameraEmbedding(io.ComfyNode):
                 io.Int.Input("height", default=480, min=16, max=nodes.MAX_RESOLUTION, step=16),
                 io.Int.Input("length", default=81, min=1, max=nodes.MAX_RESOLUTION, step=4),
                 io.Float.Input("speed", default=1.0, min=0, max=10.0, step=0.1, optional=True),
-                io.Float.Input("fx", default=0.5, min=0, max=1, step=0.000000001, optional=True),
-                io.Float.Input("fy", default=0.5, min=0, max=1, step=0.000000001, optional=True),
-                io.Float.Input("cx", default=0.5, min=0, max=1, step=0.01, optional=True),
-                io.Float.Input("cy", default=0.5, min=0, max=1, step=0.01, optional=True),
+                io.Float.Input("fx", default=0.5, min=0, max=1, step=0.000000001, optional=True, advanced=True),
+                io.Float.Input("fy", default=0.5, min=0, max=1, step=0.000000001, optional=True, advanced=True),
+                io.Float.Input("cx", default=0.5, min=0, max=1, step=0.01, optional=True, advanced=True),
+                io.Float.Input("cy", default=0.5, min=0, max=1, step=0.01, optional=True, advanced=True),
             ],
             outputs=[
                 io.WanCameraEmbedding.Output(display_name="camera_embedding"),

comfy_extras/nodes_canny.py

@@ -12,7 +12,6 @@ class Canny(io.ComfyNode):
             node_id="Canny",
             search_aliases=["edge detection", "outline", "contour detection", "line art"],
             category="image/preprocessors",
-            main_category="Image Tools/Preprocessing",
             inputs=[
                 io.Image.Input("image"),
                 io.Float.Input("low_threshold", default=0.4, min=0.01, max=0.99, step=0.01),

comfy_extras/nodes_chroma_radiance.py

@@ -48,6 +48,7 @@ class ChromaRadianceOptions(io.ComfyNode):
                     min=0.0,
                     max=1.0,
                     tooltip="First sigma that these options will be in effect.",
+                    advanced=True,
                 ),
                 io.Float.Input(
                     id="end_sigma",
@@ -55,12 +56,14 @@ class ChromaRadianceOptions(io.ComfyNode):
                     min=0.0,
                     max=1.0,
                     tooltip="Last sigma that these options will be in effect.",
+                    advanced=True,
                 ),
                 io.Int.Input(
                     id="nerf_tile_size",
                     default=-1,
                     min=-1,
                     tooltip="Allows overriding the default NeRF tile size. -1 means use the default (32). 0 means use non-tiling mode (may require a lot of VRAM).",
+                    advanced=True,
                 ),
             ],
             outputs=[io.Model.Output()],

comfy_extras/nodes_clip_sdxl.py

@@ -35,8 +35,8 @@ class CLIPTextEncodeSDXL(io.ComfyNode):
                 io.Clip.Input("clip"),
                 io.Int.Input("width", default=1024, min=0, max=nodes.MAX_RESOLUTION),
                 io.Int.Input("height", default=1024, min=0, max=nodes.MAX_RESOLUTION),
-                io.Int.Input("crop_w", default=0, min=0, max=nodes.MAX_RESOLUTION),
-                io.Int.Input("crop_h", default=0, min=0, max=nodes.MAX_RESOLUTION),
+                io.Int.Input("crop_w", default=0, min=0, max=nodes.MAX_RESOLUTION, advanced=True),
+                io.Int.Input("crop_h", default=0, min=0, max=nodes.MAX_RESOLUTION, advanced=True),
                 io.Int.Input("target_width", default=1024, min=0, max=nodes.MAX_RESOLUTION),
                 io.Int.Input("target_height", default=1024, min=0, max=nodes.MAX_RESOLUTION),
                 io.String.Input("text_g", multiline=True, dynamic_prompts=True),

comfy_extras/nodes_cond.py

@@ -38,8 +38,8 @@ class T5TokenizerOptions(io.ComfyNode):
             category="_for_testing/conditioning",
             inputs=[
                 io.Clip.Input("clip"),
-                io.Int.Input("min_padding", default=0, min=0, max=10000, step=1),
-                io.Int.Input("min_length", default=0, min=0, max=10000, step=1),
+                io.Int.Input("min_padding", default=0, min=0, max=10000, step=1, advanced=True),
+                io.Int.Input("min_length", default=0, min=0, max=10000, step=1, advanced=True),
             ],
             outputs=[io.Clip.Output()],
             is_experimental=True,

comfy_extras/nodes_context_windows.py

@@ -14,15 +14,15 @@ class ContextWindowsManualNode(io.ComfyNode):
             description="Manually set context windows.",
             inputs=[
                 io.Model.Input("model", tooltip="The model to apply context windows to during sampling."),
-                io.Int.Input("context_length", min=1, default=16, tooltip="The length of the context window."),
-                io.Int.Input("context_overlap", min=0, default=4, tooltip="The overlap of the context window."),
+                io.Int.Input("context_length", min=1, default=16, tooltip="The length of the context window.", advanced=True),
+                io.Int.Input("context_overlap", min=0, default=4, tooltip="The overlap of the context window.", advanced=True),
                 io.Combo.Input("context_schedule", options=[
                     comfy.context_windows.ContextSchedules.STATIC_STANDARD,
                     comfy.context_windows.ContextSchedules.UNIFORM_STANDARD,
                     comfy.context_windows.ContextSchedules.UNIFORM_LOOPED,
                     comfy.context_windows.ContextSchedules.BATCHED,
                     ], tooltip="The stride of the context window."),
-                io.Int.Input("context_stride", min=1, default=1, tooltip="The stride of the context window; only applicable to uniform schedules."),
+                io.Int.Input("context_stride", min=1, default=1, tooltip="The stride of the context window; only applicable to uniform schedules.", advanced=True),
                 io.Boolean.Input("closed_loop", default=False, tooltip="Whether to close the context window loop; only applicable to looped schedules."),
                 io.Combo.Input("fuse_method", options=comfy.context_windows.ContextFuseMethods.LIST_STATIC, default=comfy.context_windows.ContextFuseMethods.PYRAMID, tooltip="The method to use to fuse the context windows."),
                 io.Int.Input("dim", min=0, max=5, default=0, tooltip="The dimension to apply the context windows to."),
@@ -67,15 +67,15 @@ class WanContextWindowsManualNode(ContextWindowsManualNode):
         schema.description = "Manually set context windows for WAN-like models (dim=2)."
         schema.inputs = [
             io.Model.Input("model", tooltip="The model to apply context windows to during sampling."),
-                io.Int.Input("context_length", min=1, max=nodes.MAX_RESOLUTION, step=4, default=81, tooltip="The length of the context window."),
-                io.Int.Input("context_overlap", min=0, default=30, tooltip="The overlap of the context window."),
+                io.Int.Input("context_length", min=1, max=nodes.MAX_RESOLUTION, step=4, default=81, tooltip="The length of the context window.", advanced=True),
+                io.Int.Input("context_overlap", min=0, default=30, tooltip="The overlap of the context window.", advanced=True),
                 io.Combo.Input("context_schedule", options=[
                     comfy.context_windows.ContextSchedules.STATIC_STANDARD,
                     comfy.context_windows.ContextSchedules.UNIFORM_STANDARD,
                     comfy.context_windows.ContextSchedules.UNIFORM_LOOPED,
                     comfy.context_windows.ContextSchedules.BATCHED,
                     ], tooltip="The stride of the context window."),
-                io.Int.Input("context_stride", min=1, default=1, tooltip="The stride of the context window; only applicable to uniform schedules."),
+                io.Int.Input("context_stride", min=1, default=1, tooltip="The stride of the context window; only applicable to uniform schedules.", advanced=True),
                 io.Boolean.Input("closed_loop", default=False, tooltip="Whether to close the context window loop; only applicable to looped schedules."),
                 io.Combo.Input("fuse_method", options=comfy.context_windows.ContextFuseMethods.LIST_STATIC, default=comfy.context_windows.ContextFuseMethods.PYRAMID, tooltip="The method to use to fuse the context windows."),
                 io.Boolean.Input("freenoise", default=False, tooltip="Whether to apply FreeNoise noise shuffling, improves window blending."),

comfy_extras/nodes_controlnet.py

@@ -48,8 +48,8 @@ class ControlNetInpaintingAliMamaApply(io.ComfyNode):
                 io.Image.Input("image"),
                 io.Mask.Input("mask"),
                 io.Float.Input("strength", default=1.0, min=0.0, max=10.0, step=0.01),
-                io.Float.Input("start_percent", default=0.0, min=0.0, max=1.0, step=0.001),
-                io.Float.Input("end_percent", default=1.0, min=0.0, max=1.0, step=0.001),
+                io.Float.Input("start_percent", default=0.0, min=0.0, max=1.0, step=0.001, advanced=True),
+                io.Float.Input("end_percent", default=1.0, min=0.0, max=1.0, step=0.001, advanced=True),
             ],
             outputs=[
                 io.Conditioning.Output(display_name="positive"),

comfy_extras/nodes_custom_sampler.py

@@ -50,9 +50,9 @@ class KarrasScheduler(io.ComfyNode):
             category="sampling/custom_sampling/schedulers",
             inputs=[
                 io.Int.Input("steps", default=20, min=1, max=10000),
-                io.Float.Input("sigma_max", default=14.614642, min=0.0, max=5000.0, step=0.01, round=False),
-                io.Float.Input("sigma_min", default=0.0291675, min=0.0, max=5000.0, step=0.01, round=False),
-                io.Float.Input("rho", default=7.0, min=0.0, max=100.0, step=0.01, round=False),
+                io.Float.Input("sigma_max", default=14.614642, min=0.0, max=5000.0, step=0.01, round=False, advanced=True),
+                io.Float.Input("sigma_min", default=0.0291675, min=0.0, max=5000.0, step=0.01, round=False, advanced=True),
+                io.Float.Input("rho", default=7.0, min=0.0, max=100.0, step=0.01, round=False, advanced=True),
             ],
             outputs=[io.Sigmas.Output()]
         )
@@ -72,8 +72,8 @@ class ExponentialScheduler(io.ComfyNode):
             category="sampling/custom_sampling/schedulers",
             inputs=[
                 io.Int.Input("steps", default=20, min=1, max=10000),
-                io.Float.Input("sigma_max", default=14.614642, min=0.0, max=5000.0, step=0.01, round=False),
-                io.Float.Input("sigma_min", default=0.0291675, min=0.0, max=5000.0, step=0.01, round=False),
+                io.Float.Input("sigma_max", default=14.614642, min=0.0, max=5000.0, step=0.01, round=False, advanced=True),
+                io.Float.Input("sigma_min", default=0.0291675, min=0.0, max=5000.0, step=0.01, round=False, advanced=True),
             ],
             outputs=[io.Sigmas.Output()]
         )
@@ -93,9 +93,9 @@ class PolyexponentialScheduler(io.ComfyNode):
             category="sampling/custom_sampling/schedulers",
             inputs=[
                 io.Int.Input("steps", default=20, min=1, max=10000),
-                io.Float.Input("sigma_max", default=14.614642, min=0.0, max=5000.0, step=0.01, round=False),
-                io.Float.Input("sigma_min", default=0.0291675, min=0.0, max=5000.0, step=0.01, round=False),
-                io.Float.Input("rho", default=1.0, min=0.0, max=100.0, step=0.01, round=False),
+                io.Float.Input("sigma_max", default=14.614642, min=0.0, max=5000.0, step=0.01, round=False, advanced=True),
+                io.Float.Input("sigma_min", default=0.0291675, min=0.0, max=5000.0, step=0.01, round=False, advanced=True),
+                io.Float.Input("rho", default=1.0, min=0.0, max=100.0, step=0.01, round=False, advanced=True),
             ],
             outputs=[io.Sigmas.Output()]
         )
@@ -115,10 +115,10 @@ class LaplaceScheduler(io.ComfyNode):
             category="sampling/custom_sampling/schedulers",
             inputs=[
                 io.Int.Input("steps", default=20, min=1, max=10000),
-                io.Float.Input("sigma_max", default=14.614642, min=0.0, max=5000.0, step=0.01, round=False),
-                io.Float.Input("sigma_min", default=0.0291675, min=0.0, max=5000.0, step=0.01, round=False),
-                io.Float.Input("mu", default=0.0, min=-10.0, max=10.0, step=0.1, round=False),
-                io.Float.Input("beta", default=0.5, min=0.0, max=10.0, step=0.1, round=False),
+                io.Float.Input("sigma_max", default=14.614642, min=0.0, max=5000.0, step=0.01, round=False, advanced=True),
+                io.Float.Input("sigma_min", default=0.0291675, min=0.0, max=5000.0, step=0.01, round=False, advanced=True),
+                io.Float.Input("mu", default=0.0, min=-10.0, max=10.0, step=0.1, round=False, advanced=True),
+                io.Float.Input("beta", default=0.5, min=0.0, max=10.0, step=0.1, round=False, advanced=True),
             ],
             outputs=[io.Sigmas.Output()]
         )
@@ -164,8 +164,8 @@ class BetaSamplingScheduler(io.ComfyNode):
             inputs=[
                 io.Model.Input("model"),
                 io.Int.Input("steps", default=20, min=1, max=10000),
-                io.Float.Input("alpha", default=0.6, min=0.0, max=50.0, step=0.01, round=False),
-                io.Float.Input("beta", default=0.6, min=0.0, max=50.0, step=0.01, round=False),
+                io.Float.Input("alpha", default=0.6, min=0.0, max=50.0, step=0.01, round=False, advanced=True),
+                io.Float.Input("beta", default=0.6, min=0.0, max=50.0, step=0.01, round=False, advanced=True),
             ],
             outputs=[io.Sigmas.Output()]
         )
@@ -185,9 +185,9 @@ class VPScheduler(io.ComfyNode):
             category="sampling/custom_sampling/schedulers",
             inputs=[
                 io.Int.Input("steps", default=20, min=1, max=10000),
-                io.Float.Input("beta_d", default=19.9, min=0.0, max=5000.0, step=0.01, round=False), #TODO: fix default values
-                io.Float.Input("beta_min", default=0.1, min=0.0, max=5000.0, step=0.01, round=False),
-                io.Float.Input("eps_s", default=0.001, min=0.0, max=1.0, step=0.0001, round=False),
+                io.Float.Input("beta_d", default=19.9, min=0.0, max=5000.0, step=0.01, round=False, advanced=True), #TODO: fix default values
+                io.Float.Input("beta_min", default=0.1, min=0.0, max=5000.0, step=0.01, round=False, advanced=True),
+                io.Float.Input("eps_s", default=0.001, min=0.0, max=1.0, step=0.0001, round=False, advanced=True),
             ],
             outputs=[io.Sigmas.Output()]
         )
@@ -398,9 +398,9 @@ class SamplerDPMPP_3M_SDE(io.ComfyNode):
             node_id="SamplerDPMPP_3M_SDE",
             category="sampling/custom_sampling/samplers",
             inputs=[
-                io.Float.Input("eta", default=1.0, min=0.0, max=100.0, step=0.01, round=False),
-                io.Float.Input("s_noise", default=1.0, min=0.0, max=100.0, step=0.01, round=False),
-                io.Combo.Input("noise_device", options=['gpu', 'cpu']),
+                io.Float.Input("eta", default=1.0, min=0.0, max=100.0, step=0.01, round=False, advanced=True),
+                io.Float.Input("s_noise", default=1.0, min=0.0, max=100.0, step=0.01, round=False, advanced=True),
+                io.Combo.Input("noise_device", options=['gpu', 'cpu'], advanced=True),
             ],
             outputs=[io.Sampler.Output()]
         )
@@ -424,9 +424,9 @@ class SamplerDPMPP_2M_SDE(io.ComfyNode):
             category="sampling/custom_sampling/samplers",
             inputs=[
                 io.Combo.Input("solver_type", options=['midpoint', 'heun']),
-                io.Float.Input("eta", default=1.0, min=0.0, max=100.0, step=0.01, round=False),
-                io.Float.Input("s_noise", default=1.0, min=0.0, max=100.0, step=0.01, round=False),
-                io.Combo.Input("noise_device", options=['gpu', 'cpu']),
+                io.Float.Input("eta", default=1.0, min=0.0, max=100.0, step=0.01, round=False, advanced=True),
+                io.Float.Input("s_noise", default=1.0, min=0.0, max=100.0, step=0.01, round=False, advanced=True),
+                io.Combo.Input("noise_device", options=['gpu', 'cpu'], advanced=True),
             ],
             outputs=[io.Sampler.Output()]
         )
@@ -450,10 +450,10 @@ class SamplerDPMPP_SDE(io.ComfyNode):
             node_id="SamplerDPMPP_SDE",
             category="sampling/custom_sampling/samplers",
             inputs=[
-                io.Float.Input("eta", default=1.0, min=0.0, max=100.0, step=0.01, round=False),
-                io.Float.Input("s_noise", default=1.0, min=0.0, max=100.0, step=0.01, round=False),
-                io.Float.Input("r", default=0.5, min=0.0, max=100.0, step=0.01, round=False),
-                io.Combo.Input("noise_device", options=['gpu', 'cpu']),
+                io.Float.Input("eta", default=1.0, min=0.0, max=100.0, step=0.01, round=False, advanced=True),
+                io.Float.Input("s_noise", default=1.0, min=0.0, max=100.0, step=0.01, round=False, advanced=True),
+                io.Float.Input("r", default=0.5, min=0.0, max=100.0, step=0.01, round=False, advanced=True),
+                io.Combo.Input("noise_device", options=['gpu', 'cpu'], advanced=True),
             ],
             outputs=[io.Sampler.Output()]
         )
@@ -496,8 +496,8 @@ class SamplerEulerAncestral(io.ComfyNode):
             node_id="SamplerEulerAncestral",
             category="sampling/custom_sampling/samplers",
             inputs=[
-                io.Float.Input("eta", default=1.0, min=0.0, max=100.0, step=0.01, round=False),
-                io.Float.Input("s_noise", default=1.0, min=0.0, max=100.0, step=0.01, round=False),
+                io.Float.Input("eta", default=1.0, min=0.0, max=100.0, step=0.01, round=False, advanced=True),
+                io.Float.Input("s_noise", default=1.0, min=0.0, max=100.0, step=0.01, round=False, advanced=True),
             ],
             outputs=[io.Sampler.Output()]
         )
@@ -538,7 +538,7 @@ class SamplerLMS(io.ComfyNode):
         return io.Schema(
             node_id="SamplerLMS",
             category="sampling/custom_sampling/samplers",
-            inputs=[io.Int.Input("order", default=4, min=1, max=100)],
+            inputs=[io.Int.Input("order", default=4, min=1, max=100, advanced=True)],
             outputs=[io.Sampler.Output()]
         )
 
@@ -556,16 +556,16 @@ class SamplerDPMAdaptative(io.ComfyNode):
             node_id="SamplerDPMAdaptative",
             category="sampling/custom_sampling/samplers",
             inputs=[
-                io.Int.Input("order", default=3, min=2, max=3),
-                io.Float.Input("rtol", default=0.05, min=0.0, max=100.0, step=0.01, round=False),
-                io.Float.Input("atol", default=0.0078, min=0.0, max=100.0, step=0.01, round=False),
-                io.Float.Input("h_init", default=0.05, min=0.0, max=100.0, step=0.01, round=False),
-                io.Float.Input("pcoeff", default=0.0, min=0.0, max=100.0, step=0.01, round=False),
-                io.Float.Input("icoeff", default=1.0, min=0.0, max=100.0, step=0.01, round=False),
-                io.Float.Input("dcoeff", default=0.0, min=0.0, max=100.0, step=0.01, round=False),
-                io.Float.Input("accept_safety", default=0.81, min=0.0, max=100.0, step=0.01, round=False),
-                io.Float.Input("eta", default=0.0, min=0.0, max=100.0, step=0.01, round=False),
-                io.Float.Input("s_noise", default=1.0, min=0.0, max=100.0, step=0.01, round=False),
+                io.Int.Input("order", default=3, min=2, max=3, advanced=True),
+                io.Float.Input("rtol", default=0.05, min=0.0, max=100.0, step=0.01, round=False, advanced=True),
+                io.Float.Input("atol", default=0.0078, min=0.0, max=100.0, step=0.01, round=False, advanced=True),
+                io.Float.Input("h_init", default=0.05, min=0.0, max=100.0, step=0.01, round=False, advanced=True),
+                io.Float.Input("pcoeff", default=0.0, min=0.0, max=100.0, step=0.01, round=False, advanced=True),
+                io.Float.Input("icoeff", default=1.0, min=0.0, max=100.0, step=0.01, round=False, advanced=True),
+                io.Float.Input("dcoeff", default=0.0, min=0.0, max=100.0, step=0.01, round=False, advanced=True),
+                io.Float.Input("accept_safety", default=0.81, min=0.0, max=100.0, step=0.01, round=False, advanced=True),
+                io.Float.Input("eta", default=0.0, min=0.0, max=100.0, step=0.01, round=False, advanced=True),
+                io.Float.Input("s_noise", default=1.0, min=0.0, max=100.0, step=0.01, round=False, advanced=True),
             ],
             outputs=[io.Sampler.Output()]
         )
@@ -588,9 +588,9 @@ class SamplerER_SDE(io.ComfyNode):
             category="sampling/custom_sampling/samplers",
             inputs=[
                 io.Combo.Input("solver_type", options=["ER-SDE", "Reverse-time SDE", "ODE"]),
-                io.Int.Input("max_stage", default=3, min=1, max=3),
-                io.Float.Input("eta", default=1.0, min=0.0, max=100.0, step=0.01, round=False, tooltip="Stochastic strength of reverse-time SDE.\nWhen eta=0, it reduces to deterministic ODE. This setting doesn't apply to ER-SDE solver type."),
-                io.Float.Input("s_noise", default=1.0, min=0.0, max=100.0, step=0.01, round=False),
+                io.Int.Input("max_stage", default=3, min=1, max=3, advanced=True),
+                io.Float.Input("eta", default=1.0, min=0.0, max=100.0, step=0.01, round=False, tooltip="Stochastic strength of reverse-time SDE.\nWhen eta=0, it reduces to deterministic ODE. This setting doesn't apply to ER-SDE solver type.", advanced=True),
+                io.Float.Input("s_noise", default=1.0, min=0.0, max=100.0, step=0.01, round=False, advanced=True),
             ],
             outputs=[io.Sampler.Output()]
         )
@@ -625,14 +625,14 @@ class SamplerSASolver(io.ComfyNode):
             category="sampling/custom_sampling/samplers",
             inputs=[
                 io.Model.Input("model"),
-                io.Float.Input("eta", default=1.0, min=0.0, max=10.0, step=0.01, round=False),
-                io.Float.Input("sde_start_percent", default=0.2, min=0.0, max=1.0, step=0.001),
-                io.Float.Input("sde_end_percent", default=0.8, min=0.0, max=1.0, step=0.001),
-                io.Float.Input("s_noise", default=1.0, min=0.0, max=100.0, step=0.01, round=False),
-                io.Int.Input("predictor_order", default=3, min=1, max=6),
-                io.Int.Input("corrector_order", default=4, min=0, max=6),
-                io.Boolean.Input("use_pece"),
-                io.Boolean.Input("simple_order_2"),
+                io.Float.Input("eta", default=1.0, min=0.0, max=10.0, step=0.01, round=False, advanced=True),
+                io.Float.Input("sde_start_percent", default=0.2, min=0.0, max=1.0, step=0.001, advanced=True),
+                io.Float.Input("sde_end_percent", default=0.8, min=0.0, max=1.0, step=0.001, advanced=True),
+                io.Float.Input("s_noise", default=1.0, min=0.0, max=100.0, step=0.01, round=False, advanced=True),
+                io.Int.Input("predictor_order", default=3, min=1, max=6, advanced=True),
+                io.Int.Input("corrector_order", default=4, min=0, max=6, advanced=True),
+                io.Boolean.Input("use_pece", advanced=True),
+                io.Boolean.Input("simple_order_2", advanced=True),
             ],
             outputs=[io.Sampler.Output()]
         )
@@ -669,9 +669,9 @@ class SamplerSEEDS2(io.ComfyNode):
             category="sampling/custom_sampling/samplers",
             inputs=[
                 io.Combo.Input("solver_type", options=["phi_1", "phi_2"]),
-                io.Float.Input("eta", default=1.0, min=0.0, max=100.0, step=0.01, round=False, tooltip="Stochastic strength"),
-                io.Float.Input("s_noise", default=1.0, min=0.0, max=100.0, step=0.01, round=False, tooltip="SDE noise multiplier"),
-                io.Float.Input("r", default=0.5, min=0.01, max=1.0, step=0.01, round=False, tooltip="Relative step size for the intermediate stage (c2 node)"),
+                io.Float.Input("eta", default=1.0, min=0.0, max=100.0, step=0.01, round=False, tooltip="Stochastic strength", advanced=True),
+                io.Float.Input("s_noise", default=1.0, min=0.0, max=100.0, step=0.01, round=False, tooltip="SDE noise multiplier", advanced=True),
+                io.Float.Input("r", default=0.5, min=0.01, max=1.0, step=0.01, round=False, tooltip="Relative step size for the intermediate stage (c2 node)", advanced=True),
             ],
             outputs=[io.Sampler.Output()],
             description=(
@@ -728,7 +728,7 @@ class SamplerCustom(io.ComfyNode):
             category="sampling/custom_sampling",
             inputs=[
                 io.Model.Input("model"),
-                io.Boolean.Input("add_noise", default=True),
+                io.Boolean.Input("add_noise", default=True, advanced=True),
                 io.Int.Input("noise_seed", default=0, min=0, max=0xffffffffffffffff, control_after_generate=True),
                 io.Float.Input("cfg", default=8.0, min=0.0, max=100.0, step=0.1, round=0.01),
                 io.Conditioning.Input("positive"),

comfy_extras/nodes_dataset.py

@@ -222,6 +222,7 @@ class SaveImageDataSetToFolderNode(io.ComfyNode):
                     "filename_prefix",
                     default="image",
                     tooltip="Prefix for saved image filenames.",
+                    advanced=True,
                 ),
             ],
             outputs=[],
@@ -262,6 +263,7 @@ class SaveImageTextDataSetToFolderNode(io.ComfyNode):
                     "filename_prefix",
                     default="image",
                     tooltip="Prefix for saved image filenames.",
+                    advanced=True,
                 ),
             ],
             outputs=[],
@@ -741,6 +743,7 @@ class NormalizeImagesNode(ImageProcessingNode):
             min=0.0,
             max=1.0,
             tooltip="Mean value for normalization.",
+            advanced=True,
         ),
         io.Float.Input(
             "std",
@@ -748,6 +751,7 @@ class NormalizeImagesNode(ImageProcessingNode):
             min=0.001,
             max=1.0,
             tooltip="Standard deviation for normalization.",
+            advanced=True,
         ),
     ]
 
@@ -961,6 +965,7 @@ class ImageDeduplicationNode(ImageProcessingNode):
             min=0.0,
             max=1.0,
             tooltip="Similarity threshold (0-1). Higher means more similar. Images above this threshold are considered duplicates.",
+            advanced=True,
         ),
     ]
 
@@ -1039,6 +1044,7 @@ class ImageGridNode(ImageProcessingNode):
             min=32,
             max=2048,
             tooltip="Width of each cell in the grid.",
+            advanced=True,
         ),
         io.Int.Input(
             "cell_height",
@@ -1046,9 +1052,10 @@ class ImageGridNode(ImageProcessingNode):
             min=32,
             max=2048,
             tooltip="Height of each cell in the grid.",
+            advanced=True,
         ),
         io.Int.Input(
-            "padding", default=4, min=0, max=50, tooltip="Padding between images."
+            "padding", default=4, min=0, max=50, tooltip="Padding between images.", advanced=True
         ),
     ]
 
@@ -1339,6 +1346,7 @@ class SaveTrainingDataset(io.ComfyNode):
                     min=1,
                     max=100000,
                     tooltip="Number of samples per shard file.",
+                    advanced=True,
                 ),
             ],
             outputs=[],

comfy_extras/nodes_easycache.py

@@ -9,6 +9,14 @@ if TYPE_CHECKING:
     from uuid import UUID
 
 
+def _extract_tensor(data, output_channels):
+    """Extract tensor from data, handling both single tensors and lists."""
+    if isinstance(data, list):
+        # LTX2 AV tensors: [video, audio]
+        return data[0][:, :output_channels], data[1][:, :output_channels]
+    return data[:, :output_channels], None
+
+
 def easycache_forward_wrapper(executor, *args, **kwargs):
     # get values from args
     transformer_options: dict[str] = args[-1]
@@ -17,7 +25,7 @@ def easycache_forward_wrapper(executor, *args, **kwargs):
         if not transformer_options:
             transformer_options = args[-2]
     easycache: EasyCacheHolder = transformer_options["easycache"]
-    x: torch.Tensor = args[0][:, :easycache.output_channels]
+    x, ax = _extract_tensor(args[0], easycache.output_channels)
     sigmas = transformer_options["sigmas"]
     uuids = transformer_options["uuids"]
     if sigmas is not None and easycache.is_past_end_timestep(sigmas):
@@ -35,7 +43,11 @@ def easycache_forward_wrapper(executor, *args, **kwargs):
         if easycache.skip_current_step and can_apply_cache_diff:
             if easycache.verbose:
                 logging.info(f"EasyCache [verbose] - was marked to skip this step by {easycache.first_cond_uuid}. Present uuids: {uuids}")
-            return easycache.apply_cache_diff(x, uuids)
+            result = easycache.apply_cache_diff(x, uuids)
+            if ax is not None:
+                result_audio = easycache.apply_cache_diff(ax, uuids, is_audio=True)
+                return [result, result_audio]
+            return result
         if easycache.initial_step:
             easycache.first_cond_uuid = uuids[0]
             has_first_cond_uuid = easycache.has_first_cond_uuid(uuids)
@@ -51,13 +63,18 @@ def easycache_forward_wrapper(executor, *args, **kwargs):
                         logging.info(f"EasyCache [verbose] - skipping step; cumulative_change_rate: {easycache.cumulative_change_rate}, reuse_threshold: {easycache.reuse_threshold}")
                     # other conds should also skip this step, and instead use their cached values
                     easycache.skip_current_step = True
-                    return easycache.apply_cache_diff(x, uuids)
+                    result = easycache.apply_cache_diff(x, uuids)
+                    if ax is not None:
+                        result_audio = easycache.apply_cache_diff(ax, uuids, is_audio=True)
+                        return [result, result_audio]
+                    return result
                 else:
                     if easycache.verbose:
                         logging.info(f"EasyCache [verbose] - NOT skipping step; cumulative_change_rate: {easycache.cumulative_change_rate}, reuse_threshold: {easycache.reuse_threshold}")
                     easycache.cumulative_change_rate = 0.0
 
-    output: torch.Tensor = executor(*args, **kwargs)
+    full_output: torch.Tensor = executor(*args, **kwargs)
+    output, audio_output = _extract_tensor(full_output, easycache.output_channels)
     if has_first_cond_uuid and easycache.has_output_prev_norm():
         output_change = (easycache.subsample(output, uuids, clone=False) - easycache.output_prev_subsampled).flatten().abs().mean()
         if easycache.verbose:
@@ -74,13 +91,15 @@ def easycache_forward_wrapper(executor, *args, **kwargs):
             logging.info(f"EasyCache [verbose] - output_change_rate: {output_change_rate}")
     # TODO: allow cache_diff to be offloaded
     easycache.update_cache_diff(output, next_x_prev, uuids)
+    if audio_output is not None:
+        easycache.update_cache_diff(audio_output, ax, uuids, is_audio=True)
     if has_first_cond_uuid:
         easycache.x_prev_subsampled = easycache.subsample(next_x_prev, uuids)
         easycache.output_prev_subsampled = easycache.subsample(output, uuids)
         easycache.output_prev_norm = output.flatten().abs().mean()
         if easycache.verbose:
             logging.info(f"EasyCache [verbose] - x_prev_subsampled: {easycache.x_prev_subsampled.shape}")
-    return output
+    return full_output
 
 def lazycache_predict_noise_wrapper(executor, *args, **kwargs):
     # get values from args
@@ -89,8 +108,8 @@ def lazycache_predict_noise_wrapper(executor, *args, **kwargs):
     easycache: LazyCacheHolder = model_options["transformer_options"]["easycache"]
     if easycache.is_past_end_timestep(timestep):
         return executor(*args, **kwargs)
+    x: torch.Tensor = _extract_tensor(args[0], easycache.output_channels)
     # prepare next x_prev
-    x: torch.Tensor = args[0][:, :easycache.output_channels]
     next_x_prev = x
     input_change = None
     do_easycache = easycache.should_do_easycache(timestep)
@@ -197,6 +216,7 @@ class EasyCacheHolder:
         self.output_prev_subsampled: torch.Tensor = None
         self.output_prev_norm: torch.Tensor = None
         self.uuid_cache_diffs: dict[UUID, torch.Tensor] = {}
+        self.uuid_cache_diffs_audio: dict[UUID, torch.Tensor] = {}
         self.output_change_rates = []
         self.approx_output_change_rates = []
         self.total_steps_skipped = 0
@@ -245,20 +265,21 @@ class EasyCacheHolder:
     def can_apply_cache_diff(self, uuids: list[UUID]) -> bool:
         return all(uuid in self.uuid_cache_diffs for uuid in uuids)
 
-    def apply_cache_diff(self, x: torch.Tensor, uuids: list[UUID]):
-        if self.first_cond_uuid in uuids:
+    def apply_cache_diff(self, x: torch.Tensor, uuids: list[UUID], is_audio: bool = False):
+        if self.first_cond_uuid in uuids and not is_audio:
             self.total_steps_skipped += 1
+        cache_diffs = self.uuid_cache_diffs_audio if is_audio else self.uuid_cache_diffs
         batch_offset = x.shape[0] // len(uuids)
         for i, uuid in enumerate(uuids):
             # slice out only what is relevant to this cond
             batch_slice = [slice(i*batch_offset,(i+1)*batch_offset)]
             # if cached dims don't match x dims, cut off excess and hope for the best (cosmos world2video)
-            if x.shape[1:] != self.uuid_cache_diffs[uuid].shape[1:]:
+            if x.shape[1:] != cache_diffs[uuid].shape[1:]:
                 if not self.allow_mismatch:
                     raise ValueError(f"Cached dims {self.uuid_cache_diffs[uuid].shape} don't match x dims {x.shape} - this is no good")
                 slicing = []
                 skip_this_dim = True
-                for dim_u, dim_x in zip(self.uuid_cache_diffs[uuid].shape, x.shape):
+                for dim_u, dim_x in zip(cache_diffs[uuid].shape, x.shape):
                     if skip_this_dim:
                         skip_this_dim = False
                         continue
@@ -270,10 +291,11 @@ class EasyCacheHolder:
                     else:
                         slicing.append(slice(None))
                 batch_slice = batch_slice + slicing
-            x[tuple(batch_slice)] += self.uuid_cache_diffs[uuid].to(x.device)
+            x[tuple(batch_slice)] += cache_diffs[uuid].to(x.device)
         return x
 
-    def update_cache_diff(self, output: torch.Tensor, x: torch.Tensor, uuids: list[UUID]):
+    def update_cache_diff(self, output: torch.Tensor, x: torch.Tensor, uuids: list[UUID], is_audio: bool = False):
+        cache_diffs = self.uuid_cache_diffs_audio if is_audio else self.uuid_cache_diffs
         # if output dims don't match x dims, cut off excess and hope for the best (cosmos world2video)
         if output.shape[1:] != x.shape[1:]:
             if not self.allow_mismatch:
@@ -293,7 +315,7 @@ class EasyCacheHolder:
         diff = output - x
         batch_offset = diff.shape[0] // len(uuids)
         for i, uuid in enumerate(uuids):
-            self.uuid_cache_diffs[uuid] = diff[i*batch_offset:(i+1)*batch_offset, ...]
+            cache_diffs[uuid] = diff[i*batch_offset:(i+1)*batch_offset, ...]
 
     def has_first_cond_uuid(self, uuids: list[UUID]) -> bool:
         return self.first_cond_uuid in uuids
@@ -324,6 +346,8 @@ class EasyCacheHolder:
         self.output_prev_norm = None
         del self.uuid_cache_diffs
         self.uuid_cache_diffs = {}
+        del self.uuid_cache_diffs_audio
+        self.uuid_cache_diffs_audio = {}
         self.total_steps_skipped = 0
         self.state_metadata = None
         return self
@@ -343,10 +367,10 @@ class EasyCacheNode(io.ComfyNode):
             is_experimental=True,
             inputs=[
                 io.Model.Input("model", tooltip="The model to add EasyCache to."),
-                io.Float.Input("reuse_threshold", min=0.0, default=0.2, max=3.0, step=0.01, tooltip="The threshold for reusing cached steps."),
-                io.Float.Input("start_percent", min=0.0, default=0.15, max=1.0, step=0.01, tooltip="The relative sampling step to begin use of EasyCache."),
-                io.Float.Input("end_percent", min=0.0, default=0.95, max=1.0, step=0.01, tooltip="The relative sampling step to end use of EasyCache."),
-                io.Boolean.Input("verbose", default=False, tooltip="Whether to log verbose information."),
+                io.Float.Input("reuse_threshold", min=0.0, default=0.2, max=3.0, step=0.01, tooltip="The threshold for reusing cached steps.", advanced=True),
+                io.Float.Input("start_percent", min=0.0, default=0.15, max=1.0, step=0.01, tooltip="The relative sampling step to begin use of EasyCache.", advanced=True),
+                io.Float.Input("end_percent", min=0.0, default=0.95, max=1.0, step=0.01, tooltip="The relative sampling step to end use of EasyCache.", advanced=True),
+                io.Boolean.Input("verbose", default=False, tooltip="Whether to log verbose information.", advanced=True),
             ],
             outputs=[
                 io.Model.Output(tooltip="The model with EasyCache."),
@@ -476,10 +500,10 @@ class LazyCacheNode(io.ComfyNode):
             is_experimental=True,
             inputs=[
                 io.Model.Input("model", tooltip="The model to add LazyCache to."),
-                io.Float.Input("reuse_threshold", min=0.0, default=0.2, max=3.0, step=0.01, tooltip="The threshold for reusing cached steps."),
-                io.Float.Input("start_percent", min=0.0, default=0.15, max=1.0, step=0.01, tooltip="The relative sampling step to begin use of LazyCache."),
-                io.Float.Input("end_percent", min=0.0, default=0.95, max=1.0, step=0.01, tooltip="The relative sampling step to end use of LazyCache."),
-                io.Boolean.Input("verbose", default=False, tooltip="Whether to log verbose information."),
+                io.Float.Input("reuse_threshold", min=0.0, default=0.2, max=3.0, step=0.01, tooltip="The threshold for reusing cached steps.", advanced=True),
+                io.Float.Input("start_percent", min=0.0, default=0.15, max=1.0, step=0.01, tooltip="The relative sampling step to begin use of LazyCache.", advanced=True),
+                io.Float.Input("end_percent", min=0.0, default=0.95, max=1.0, step=0.01, tooltip="The relative sampling step to end use of LazyCache.", advanced=True),
+                io.Boolean.Input("verbose", default=False, tooltip="Whether to log verbose information.", advanced=True),
             ],
             outputs=[
                 io.Model.Output(tooltip="The model with LazyCache."),

comfy_extras/nodes_eps.py

@@ -28,6 +28,7 @@ class EpsilonScaling(io.ComfyNode):
                     max=1.5,
                     step=0.001,
                     display_mode=io.NumberDisplay.number,
+                    advanced=True,
                 ),
             ],
             outputs=[
@@ -97,6 +98,7 @@ class TemporalScoreRescaling(io.ComfyNode):
                     max=100.0,
                     step=0.001,
                     display_mode=io.NumberDisplay.number,
+                    advanced=True,
                 ),
                 io.Float.Input(
                     "tsr_sigma",
@@ -109,6 +111,7 @@ class TemporalScoreRescaling(io.ComfyNode):
                     max=100.0,
                     step=0.001,
                     display_mode=io.NumberDisplay.number,
+                    advanced=True,
                 ),
             ],
             outputs=[

comfy_extras/nodes_flux.py

@@ -161,6 +161,7 @@ class FluxKontextMultiReferenceLatentMethod(io.ComfyNode):
                 io.Combo.Input(
                     "reference_latents_method",
                     options=["offset", "index", "uxo/uno", "index_timestep_zero"],
+                    advanced=True,
                 ),
             ],
             outputs=[

comfy_extras/nodes_freelunch.py

@@ -32,10 +32,10 @@ class FreeU(IO.ComfyNode):
             category="model_patches/unet",
             inputs=[
                 IO.Model.Input("model"),
-                IO.Float.Input("b1", default=1.1, min=0.0, max=10.0, step=0.01),
-                IO.Float.Input("b2", default=1.2, min=0.0, max=10.0, step=0.01),
-                IO.Float.Input("s1", default=0.9, min=0.0, max=10.0, step=0.01),
-                IO.Float.Input("s2", default=0.2, min=0.0, max=10.0, step=0.01),
+                IO.Float.Input("b1", default=1.1, min=0.0, max=10.0, step=0.01, advanced=True),
+                IO.Float.Input("b2", default=1.2, min=0.0, max=10.0, step=0.01, advanced=True),
+                IO.Float.Input("s1", default=0.9, min=0.0, max=10.0, step=0.01, advanced=True),
+                IO.Float.Input("s2", default=0.2, min=0.0, max=10.0, step=0.01, advanced=True),
             ],
             outputs=[
                 IO.Model.Output(),
@@ -79,10 +79,10 @@ class FreeU_V2(IO.ComfyNode):
             category="model_patches/unet",
             inputs=[
                 IO.Model.Input("model"),
-                IO.Float.Input("b1", default=1.3, min=0.0, max=10.0, step=0.01),
-                IO.Float.Input("b2", default=1.4, min=0.0, max=10.0, step=0.01),
-                IO.Float.Input("s1", default=0.9, min=0.0, max=10.0, step=0.01),
-                IO.Float.Input("s2", default=0.2, min=0.0, max=10.0, step=0.01),
+                IO.Float.Input("b1", default=1.3, min=0.0, max=10.0, step=0.01, advanced=True),
+                IO.Float.Input("b2", default=1.4, min=0.0, max=10.0, step=0.01, advanced=True),
+                IO.Float.Input("s1", default=0.9, min=0.0, max=10.0, step=0.01, advanced=True),
+                IO.Float.Input("s2", default=0.2, min=0.0, max=10.0, step=0.01, advanced=True),
             ],
             outputs=[
                 IO.Model.Output(),

comfy_extras/nodes_fresca.py

@@ -65,11 +65,11 @@ class FreSca(io.ComfyNode):
             inputs=[
                 io.Model.Input("model"),
                 io.Float.Input("scale_low", default=1.0, min=0, max=10, step=0.01,
-                               tooltip="Scaling factor for low-frequency components"),
+                               tooltip="Scaling factor for low-frequency components", advanced=True),
                 io.Float.Input("scale_high", default=1.25, min=0, max=10, step=0.01,
-                               tooltip="Scaling factor for high-frequency components"),
+                               tooltip="Scaling factor for high-frequency components", advanced=True),
                 io.Int.Input("freq_cutoff", default=20, min=1, max=10000, step=1,
-                             tooltip="Number of frequency indices around center to consider as low-frequency"),
+                             tooltip="Number of frequency indices around center to consider as low-frequency", advanced=True),
             ],
             outputs=[
                 io.Model.Output(),

comfy_extras/nodes_gits.py

@@ -342,7 +342,7 @@ class GITSScheduler(io.ComfyNode):
             node_id="GITSScheduler",
             category="sampling/custom_sampling/schedulers",
             inputs=[
-                io.Float.Input("coeff", default=1.20, min=0.80, max=1.50, step=0.05),
+                io.Float.Input("coeff", default=1.20, min=0.80, max=1.50, step=0.05, advanced=True),
                 io.Int.Input("steps", default=10, min=2, max=1000),
                 io.Float.Input("denoise", default=1.0, min=0.0, max=1.0, step=0.01),
             ],

comfy_extras/nodes_hooks.py

@@ -233,8 +233,8 @@ class SetClipHooks:
         return {
             "required": {
                 "clip": ("CLIP",),
-                "apply_to_conds": ("BOOLEAN", {"default": True}),
-                "schedule_clip": ("BOOLEAN", {"default": False})
+                "apply_to_conds": ("BOOLEAN", {"default": True, "advanced": True}),
+                "schedule_clip": ("BOOLEAN", {"default": False, "advanced": True})
             },
             "optional": {
                 "hooks": ("HOOKS",)
@@ -512,7 +512,7 @@ class CreateHookKeyframesInterpolated:
                 "start_percent": ("FLOAT", {"default": 0.0, "min": 0.0, "max": 1.0, "step": 0.001}),
                 "end_percent": ("FLOAT", {"default": 1.0, "min": 0.0, "max": 1.0, "step": 0.001}),
                 "keyframes_count": ("INT", {"default": 5, "min": 2, "max": 100, "step": 1}),
-                "print_keyframes": ("BOOLEAN", {"default": False}),
+                "print_keyframes": ("BOOLEAN", {"default": False, "advanced": True}),
             },
             "optional": {
                 "prev_hook_kf": ("HOOK_KEYFRAMES",),
@@ -557,7 +557,7 @@ class CreateHookKeyframesFromFloats:
                 "floats_strength": ("FLOATS", {"default": -1, "min": -1, "step": 0.001, "forceInput": True}),
                 "start_percent": ("FLOAT", {"default": 0.0, "min": 0.0, "max": 1.0, "step": 0.001}),
                 "end_percent": ("FLOAT", {"default": 1.0, "min": 0.0, "max": 1.0, "step": 0.001}),
-                "print_keyframes": ("BOOLEAN", {"default": False}),
+                "print_keyframes": ("BOOLEAN", {"default": False, "advanced": True}),
             },
             "optional": {
                 "prev_hook_kf": ("HOOK_KEYFRAMES",),

comfy_extras/nodes_hunyuan.py

@@ -138,7 +138,7 @@ class HunyuanVideo15SuperResolution(io.ComfyNode):
                 io.Image.Input("start_image", optional=True),
                 io.ClipVisionOutput.Input("clip_vision_output", optional=True),
                 io.Latent.Input("latent"),
-                io.Float.Input("noise_augmentation", default=0.70, min=0.0, max=1.0, step=0.01),
+                io.Float.Input("noise_augmentation", default=0.70, min=0.0, max=1.0, step=0.01, advanced=True),
 
             ],
             outputs=[
@@ -285,6 +285,7 @@ class TextEncodeHunyuanVideo_ImageToVideo(io.ComfyNode):
                     min=1,
                     max=512,
                     tooltip="How much the image influences things vs the text prompt. Higher number means more influence from the text prompt.",
+                    advanced=True,
                 ),
             ],
             outputs=[
@@ -313,7 +314,7 @@ class HunyuanImageToVideo(io.ComfyNode):
                 io.Int.Input("height", default=480, min=16, max=nodes.MAX_RESOLUTION, step=16),
                 io.Int.Input("length", default=53, min=1, max=nodes.MAX_RESOLUTION, step=4),
                 io.Int.Input("batch_size", default=1, min=1, max=4096),
-                io.Combo.Input("guidance_type", options=["v1 (concat)", "v2 (replace)", "custom"]),
+                io.Combo.Input("guidance_type", options=["v1 (concat)", "v2 (replace)", "custom"], advanced=True),
                 io.Image.Input("start_image", optional=True),
             ],
             outputs=[
@@ -384,7 +385,7 @@ class HunyuanRefinerLatent(io.ComfyNode):
                 io.Conditioning.Input("positive"),
                 io.Conditioning.Input("negative"),
                 io.Latent.Input("latent"),
-                io.Float.Input("noise_augmentation", default=0.10, min=0.0, max=1.0, step=0.01),
+                io.Float.Input("noise_augmentation", default=0.10, min=0.0, max=1.0, step=0.01, advanced=True),
 
             ],
             outputs=[

comfy_extras/nodes_hunyuan3d.py

@@ -106,8 +106,8 @@ class VAEDecodeHunyuan3D(IO.ComfyNode):
             inputs=[
                 IO.Latent.Input("samples"),
                 IO.Vae.Input("vae"),
-                IO.Int.Input("num_chunks", default=8000, min=1000, max=500000),
-                IO.Int.Input("octree_resolution", default=256, min=16, max=512),
+                IO.Int.Input("num_chunks", default=8000, min=1000, max=500000, advanced=True),
+                IO.Int.Input("octree_resolution", default=256, min=16, max=512, advanced=True),
             ],
             outputs=[
                 IO.Voxel.Output(),
@@ -456,7 +456,7 @@ class VoxelToMesh(IO.ComfyNode):
             category="3d",
             inputs=[
                 IO.Voxel.Input("voxel"),
-                IO.Combo.Input("algorithm", options=["surface net", "basic"]),
+                IO.Combo.Input("algorithm", options=["surface net", "basic"], advanced=True),
                 IO.Float.Input("threshold", default=0.6, min=-1.0, max=1.0, step=0.01),
             ],
             outputs=[
@@ -621,7 +621,6 @@ class SaveGLB(IO.ComfyNode):
             display_name="Save 3D Model",
             search_aliases=["export 3d model", "save mesh"],
             category="3d",
-            main_category="Basic",
             is_output_node=True,
             inputs=[
                 IO.MultiType.Input(

comfy_extras/nodes_hypertile.py

@@ -30,10 +30,10 @@ class HyperTile(io.ComfyNode):
             category="model_patches/unet",
             inputs=[
                 io.Model.Input("model"),
-                io.Int.Input("tile_size", default=256, min=1, max=2048),
-                io.Int.Input("swap_size", default=2, min=1, max=128),
-                io.Int.Input("max_depth", default=0, min=0, max=10),
-                io.Boolean.Input("scale_depth", default=False),
+                io.Int.Input("tile_size", default=256, min=1, max=2048, advanced=True),
+                io.Int.Input("swap_size", default=2, min=1, max=128, advanced=True),
+                io.Int.Input("max_depth", default=0, min=0, max=10, advanced=True),
+                io.Boolean.Input("scale_depth", default=False, advanced=True),
             ],
             outputs=[
                 io.Model.Output(),

comfy_extras/nodes_images.py

@@ -25,7 +25,6 @@ class ImageCrop(IO.ComfyNode):
             search_aliases=["trim"],
             display_name="Image Crop",
             category="image/transform",
-            main_category="Image Tools",
             inputs=[
                 IO.Image.Input("image"),
                 IO.Int.Input("width", default=512, min=1, max=nodes.MAX_RESOLUTION, step=1),
@@ -176,7 +175,7 @@ class SaveAnimatedPNG(IO.ComfyNode):
                 IO.Image.Input("images"),
                 IO.String.Input("filename_prefix", default="ComfyUI"),
                 IO.Float.Input("fps", default=6.0, min=0.01, max=1000.0, step=0.01),
-                IO.Int.Input("compress_level", default=4, min=0, max=9),
+                IO.Int.Input("compress_level", default=4, min=0, max=9, advanced=True),
             ],
             hidden=[IO.Hidden.prompt, IO.Hidden.extra_pnginfo],
             is_output_node=True,
@@ -213,8 +212,8 @@ class ImageStitch(IO.ComfyNode):
                 IO.Image.Input("image1"),
                 IO.Combo.Input("direction", options=["right", "down", "left", "up"], default="right"),
                 IO.Boolean.Input("match_image_size", default=True),
-                IO.Int.Input("spacing_width", default=0, min=0, max=1024, step=2),
-                IO.Combo.Input("spacing_color", options=["white", "black", "red", "green", "blue"], default="white"),
+                IO.Int.Input("spacing_width", default=0, min=0, max=1024, step=2, advanced=True),
+                IO.Combo.Input("spacing_color", options=["white", "black", "red", "green", "blue"], default="white", advanced=True),
                 IO.Image.Input("image2", optional=True),
             ],
             outputs=[IO.Image.Output()],
@@ -384,8 +383,8 @@ class ResizeAndPadImage(IO.ComfyNode):
                 IO.Image.Input("image"),
                 IO.Int.Input("target_width", default=512, min=1, max=nodes.MAX_RESOLUTION, step=1),
                 IO.Int.Input("target_height", default=512, min=1, max=nodes.MAX_RESOLUTION, step=1),
-                IO.Combo.Input("padding_color", options=["white", "black"]),
-                IO.Combo.Input("interpolation", options=["area", "bicubic", "nearest-exact", "bilinear", "lanczos"]),
+                IO.Combo.Input("padding_color", options=["white", "black"], advanced=True),
+                IO.Combo.Input("interpolation", options=["area", "bicubic", "nearest-exact", "bilinear", "lanczos"], advanced=True),
             ],
             outputs=[IO.Image.Output()],
         )
@@ -538,7 +537,6 @@ class ImageRotate(IO.ComfyNode):
             node_id="ImageRotate",
             search_aliases=["turn", "flip orientation"],
             category="image/transform",
-            main_category="Image Tools",
             inputs=[
                 IO.Image.Input("image"),
                 IO.Combo.Input("rotation", options=["none", "90 degrees", "180 degrees", "270 degrees"]),

comfy_extras/nodes_latent.py

@@ -412,9 +412,9 @@ class LatentOperationSharpen(io.ComfyNode):
             category="latent/advanced/operations",
             is_experimental=True,
             inputs=[
-                io.Int.Input("sharpen_radius", default=9, min=1, max=31, step=1),
-                io.Float.Input("sigma", default=1.0, min=0.1, max=10.0, step=0.1),
-                io.Float.Input("alpha", default=0.1, min=0.0, max=5.0, step=0.01),
+                io.Int.Input("sharpen_radius", default=9, min=1, max=31, step=1, advanced=True),
+                io.Float.Input("sigma", default=1.0, min=0.1, max=10.0, step=0.1, advanced=True),
+                io.Float.Input("alpha", default=0.1, min=0.0, max=5.0, step=0.01, advanced=True),
             ],
             outputs=[
                 io.LatentOperation.Output(),

comfy_extras/nodes_load_3d.py

@@ -31,7 +31,6 @@ class Load3D(IO.ComfyNode):
             node_id="Load3D",
             display_name="Load 3D & Animation",
             category="3d",
-            main_category="Basic",
             is_experimental=True,
             inputs=[
                 IO.Combo.Input("model_file", options=sorted(files), upload=IO.UploadType.model),
@@ -98,8 +97,8 @@ class Preview3D(IO.ComfyNode):
                     ],
                     tooltip="3D model file or path string",
                 ),
-                IO.Load3DCamera.Input("camera_info", optional=True),
-                IO.Image.Input("bg_image", optional=True),
+                IO.Load3DCamera.Input("camera_info", optional=True, advanced=True),
+                IO.Image.Input("bg_image", optional=True, advanced=True),
             ],
             outputs=[],
         )

comfy_extras/nodes_lora_extract.py

@@ -83,9 +83,9 @@ class LoraSave(io.ComfyNode):
             category="_for_testing",
             inputs=[
                 io.String.Input("filename_prefix", default="loras/ComfyUI_extracted_lora"),
-                io.Int.Input("rank", default=8, min=1, max=4096, step=1),
-                io.Combo.Input("lora_type", options=tuple(LORA_TYPES.keys())),
-                io.Boolean.Input("bias_diff", default=True),
+                io.Int.Input("rank", default=8, min=1, max=4096, step=1, advanced=True),
+                io.Combo.Input("lora_type", options=tuple(LORA_TYPES.keys()), advanced=True),
+                io.Boolean.Input("bias_diff", default=True, advanced=True),
                 io.Model.Input(
                     "model_diff",
                     tooltip="The ModelSubtract output to be converted to a lora.",

comfy_extras/nodes_lt.py

@@ -450,6 +450,7 @@ class LTXVScheduler(io.ComfyNode):
                     id="stretch",
                     default=True,
                     tooltip="Stretch the sigmas to be in the range [terminal, 1].",
+                    advanced=True,
                 ),
                 io.Float.Input(
                     id="terminal",
@@ -458,6 +459,7 @@ class LTXVScheduler(io.ComfyNode):
                     max=0.99,
                     step=0.01,
                     tooltip="The terminal value of the sigmas after stretching.",
+                    advanced=True,
                 ),
                 io.Latent.Input("latent", optional=True),
             ],

comfy_extras/nodes_lt_audio.py

@@ -189,6 +189,7 @@ class LTXAVTextEncoderLoader(io.ComfyNode):
                 io.Combo.Input(
                     "device",
                     options=["default", "cpu"],
+                    advanced=True,
                 )
             ],
             outputs=[io.Clip.Output()],

comfy_extras/nodes_lumina2.py

@@ -12,8 +12,8 @@ class RenormCFG(io.ComfyNode):
             category="advanced/model",
             inputs=[
                 io.Model.Input("model"),
-                io.Float.Input("cfg_trunc", default=100, min=0.0, max=100.0, step=0.01),
-                io.Float.Input("renorm_cfg", default=1.0, min=0.0, max=100.0, step=0.01),
+                io.Float.Input("cfg_trunc", default=100, min=0.0, max=100.0, step=0.01, advanced=True),
+                io.Float.Input("renorm_cfg", default=1.0, min=0.0, max=100.0, step=0.01, advanced=True),
             ],
             outputs=[
                 io.Model.Output(),

comfy_extras/nodes_mask.py

@@ -348,7 +348,7 @@ class GrowMask(IO.ComfyNode):
             inputs=[
                 IO.Mask.Input("mask"),
                 IO.Int.Input("expand", default=0, min=-nodes.MAX_RESOLUTION, max=nodes.MAX_RESOLUTION, step=1),
-                IO.Boolean.Input("tapered_corners", default=True),
+                IO.Boolean.Input("tapered_corners", default=True, advanced=True),
             ],
             outputs=[IO.Mask.Output()],
         )

comfy_extras/nodes_model_advanced.py

@@ -53,7 +53,7 @@ class ModelSamplingDiscrete:
     def INPUT_TYPES(s):
         return {"required": { "model": ("MODEL",),
                               "sampling": (["eps", "v_prediction", "lcm", "x0", "img_to_img"],),
-                              "zsnr": ("BOOLEAN", {"default": False}),
+                              "zsnr": ("BOOLEAN", {"default": False, "advanced": True}),
                               }}
 
     RETURN_TYPES = ("MODEL",)
@@ -153,8 +153,8 @@ class ModelSamplingFlux:
     @classmethod
     def INPUT_TYPES(s):
         return {"required": { "model": ("MODEL",),
-                              "max_shift": ("FLOAT", {"default": 1.15, "min": 0.0, "max": 100.0, "step":0.01}),
-                              "base_shift": ("FLOAT", {"default": 0.5, "min": 0.0, "max": 100.0, "step":0.01}),
+                              "max_shift": ("FLOAT", {"default": 1.15, "min": 0.0, "max": 100.0, "step":0.01, "advanced": True}),
+                              "base_shift": ("FLOAT", {"default": 0.5, "min": 0.0, "max": 100.0, "step":0.01, "advanced": True}),
                               "width": ("INT", {"default": 1024, "min": 16, "max": nodes.MAX_RESOLUTION, "step": 8}),
                               "height": ("INT", {"default": 1024, "min": 16, "max": nodes.MAX_RESOLUTION, "step": 8}),
                               }}
@@ -190,8 +190,8 @@ class ModelSamplingContinuousEDM:
     def INPUT_TYPES(s):
         return {"required": { "model": ("MODEL",),
                               "sampling": (["v_prediction", "edm", "edm_playground_v2.5", "eps", "cosmos_rflow"],),
-                              "sigma_max": ("FLOAT", {"default": 120.0, "min": 0.0, "max": 1000.0, "step":0.001, "round": False}),
-                              "sigma_min": ("FLOAT", {"default": 0.002, "min": 0.0, "max": 1000.0, "step":0.001, "round": False}),
+                              "sigma_max": ("FLOAT", {"default": 120.0, "min": 0.0, "max": 1000.0, "step":0.001, "round": False, "advanced": True}),
+                              "sigma_min": ("FLOAT", {"default": 0.002, "min": 0.0, "max": 1000.0, "step":0.001, "round": False, "advanced": True}),
                               }}
 
     RETURN_TYPES = ("MODEL",)
@@ -235,8 +235,8 @@ class ModelSamplingContinuousV:
     def INPUT_TYPES(s):
         return {"required": { "model": ("MODEL",),
                               "sampling": (["v_prediction"],),
-                              "sigma_max": ("FLOAT", {"default": 500.0, "min": 0.0, "max": 1000.0, "step":0.001, "round": False}),
-                              "sigma_min": ("FLOAT", {"default": 0.03, "min": 0.0, "max": 1000.0, "step":0.001, "round": False}),
+                              "sigma_max": ("FLOAT", {"default": 500.0, "min": 0.0, "max": 1000.0, "step":0.001, "round": False, "advanced": True}),
+                              "sigma_min": ("FLOAT", {"default": 0.03, "min": 0.0, "max": 1000.0, "step":0.001, "round": False, "advanced": True}),
                               }}
 
     RETURN_TYPES = ("MODEL",)
@@ -303,7 +303,7 @@ class ModelComputeDtype:
     @classmethod
     def INPUT_TYPES(s):
         return {"required": { "model": ("MODEL",),
-                              "dtype": (["default", "fp32", "fp16", "bf16"],),
+                              "dtype": (["default", "fp32", "fp16", "bf16"], {"advanced": True}),
                               }}
 
     RETURN_TYPES = ("MODEL",)

comfy_extras/nodes_model_downscale.py

@@ -13,11 +13,11 @@ class PatchModelAddDownscale(io.ComfyNode):
             category="model_patches/unet",
             inputs=[
                 io.Model.Input("model"),
-                io.Int.Input("block_number", default=3, min=1, max=32, step=1),
+                io.Int.Input("block_number", default=3, min=1, max=32, step=1, advanced=True),
                 io.Float.Input("downscale_factor", default=2.0, min=0.1, max=9.0, step=0.001),
-                io.Float.Input("start_percent", default=0.0, min=0.0, max=1.0, step=0.001),
-                io.Float.Input("end_percent", default=0.35, min=0.0, max=1.0, step=0.001),
-                io.Boolean.Input("downscale_after_skip", default=True),
+                io.Float.Input("start_percent", default=0.0, min=0.0, max=1.0, step=0.001, advanced=True),
+                io.Float.Input("end_percent", default=0.35, min=0.0, max=1.0, step=0.001, advanced=True),
+                io.Boolean.Input("downscale_after_skip", default=True, advanced=True),
                 io.Combo.Input("downscale_method", options=cls.UPSCALE_METHODS),
                 io.Combo.Input("upscale_method", options=cls.UPSCALE_METHODS),
             ],

comfy_extras/nodes_perpneg.py

@@ -29,7 +29,7 @@ class PerpNeg(io.ComfyNode):
             inputs=[
                 io.Model.Input("model"),
                 io.Conditioning.Input("empty_conditioning"),
-                io.Float.Input("neg_scale", default=1.0, min=0.0, max=100.0, step=0.01),
+                io.Float.Input("neg_scale", default=1.0, min=0.0, max=100.0, step=0.01, advanced=True),
             ],
             outputs=[
                 io.Model.Output(),
@@ -134,7 +134,7 @@ class PerpNegGuider(io.ComfyNode):
                 io.Conditioning.Input("negative"),
                 io.Conditioning.Input("empty_conditioning"),
                 io.Float.Input("cfg", default=8.0, min=0.0, max=100.0, step=0.1, round=0.01),
-                io.Float.Input("neg_scale", default=1.0, min=0.0, max=100.0, step=0.01),
+                io.Float.Input("neg_scale", default=1.0, min=0.0, max=100.0, step=0.01, advanced=True),
             ],
             outputs=[
                 io.Guider.Output(),

comfy_extras/nodes_post_processing.py

@@ -77,7 +77,6 @@ class Blur(io.ComfyNode):
         return io.Schema(
             node_id="ImageBlur",
             category="image/postprocessing",
-            main_category="Image Tools",
             inputs=[
                 io.Image.Input("image"),
                 io.Int.Input("blur_radius", default=1, min=1, max=31, step=1),
@@ -180,9 +179,9 @@ class Sharpen(io.ComfyNode):
             category="image/postprocessing",
             inputs=[
                 io.Image.Input("image"),
-                io.Int.Input("sharpen_radius", default=1, min=1, max=31, step=1),
-                io.Float.Input("sigma", default=1.0, min=0.1, max=10.0, step=0.01),
-                io.Float.Input("alpha", default=1.0, min=0.0, max=5.0, step=0.01),
+                io.Int.Input("sharpen_radius", default=1, min=1, max=31, step=1, advanced=True),
+                io.Float.Input("sigma", default=1.0, min=0.1, max=10.0, step=0.01, advanced=True),
+                io.Float.Input("alpha", default=1.0, min=0.0, max=5.0, step=0.01, advanced=True),
             ],
             outputs=[
                 io.Image.Output(),
@@ -226,7 +225,7 @@ class ImageScaleToTotalPixels(io.ComfyNode):
                 io.Image.Input("image"),
                 io.Combo.Input("upscale_method", options=cls.upscale_methods),
                 io.Float.Input("megapixels", default=1.0, min=0.01, max=16.0, step=0.01),
-                io.Int.Input("resolution_steps", default=1, min=1, max=256),
+                io.Int.Input("resolution_steps", default=1, min=1, max=256, advanced=True),
             ],
             outputs=[
                 io.Image.Output(),

comfy_extras/nodes_qwen.py

@@ -116,7 +116,7 @@ class EmptyQwenImageLayeredLatentImage(io.ComfyNode):
             inputs=[
                 io.Int.Input("width", default=640, min=16, max=nodes.MAX_RESOLUTION, step=16),
                 io.Int.Input("height", default=640, min=16, max=nodes.MAX_RESOLUTION, step=16),
-                io.Int.Input("layers", default=3, min=0, max=nodes.MAX_RESOLUTION, step=1),
+                io.Int.Input("layers", default=3, min=0, max=nodes.MAX_RESOLUTION, step=1, advanced=True),
                 io.Int.Input("batch_size", default=1, min=1, max=4096),
             ],
             outputs=[

comfy_extras/nodes_rope.py

@@ -12,14 +12,14 @@ class ScaleROPE(io.ComfyNode):
             is_experimental=True,
             inputs=[
                 io.Model.Input("model"),
-                io.Float.Input("scale_x", default=1.0, min=0.0, max=100.0, step=0.1),
-                io.Float.Input("shift_x", default=0.0, min=-256.0, max=256.0, step=0.1),
+                io.Float.Input("scale_x", default=1.0, min=0.0, max=100.0, step=0.1, advanced=True),
+                io.Float.Input("shift_x", default=0.0, min=-256.0, max=256.0, step=0.1, advanced=True),
 
-                io.Float.Input("scale_y", default=1.0, min=0.0, max=100.0, step=0.1),
-                io.Float.Input("shift_y", default=0.0, min=-256.0, max=256.0, step=0.1),
+                io.Float.Input("scale_y", default=1.0, min=0.0, max=100.0, step=0.1, advanced=True),
+                io.Float.Input("shift_y", default=0.0, min=-256.0, max=256.0, step=0.1, advanced=True),
 
-                io.Float.Input("scale_t", default=1.0, min=0.0, max=100.0, step=0.1),
-                io.Float.Input("shift_t", default=0.0, min=-256.0, max=256.0, step=0.1),
+                io.Float.Input("scale_t", default=1.0, min=0.0, max=100.0, step=0.1, advanced=True),
+                io.Float.Input("shift_t", default=0.0, min=-256.0, max=256.0, step=0.1, advanced=True),
 
 
             ],

comfy_extras/nodes_sag.py

@@ -117,7 +117,7 @@ class SelfAttentionGuidance(io.ComfyNode):
             inputs=[
                 io.Model.Input("model"),
                 io.Float.Input("scale", default=0.5, min=-2.0, max=5.0, step=0.01),
-                io.Float.Input("blur_sigma", default=2.0, min=0.0, max=10.0, step=0.1),
+                io.Float.Input("blur_sigma", default=2.0, min=0.0, max=10.0, step=0.1, advanced=True),
             ],
             outputs=[
                 io.Model.Output(),

comfy_extras/nodes_sd3.py

@@ -72,7 +72,7 @@ class CLIPTextEncodeSD3(io.ComfyNode):
                 io.String.Input("clip_l", multiline=True, dynamic_prompts=True),
                 io.String.Input("clip_g", multiline=True, dynamic_prompts=True),
                 io.String.Input("t5xxl", multiline=True, dynamic_prompts=True),
-                io.Combo.Input("empty_padding", options=["none", "empty_prompt"]),
+                io.Combo.Input("empty_padding", options=["none", "empty_prompt"], advanced=True),
             ],
             outputs=[
                 io.Conditioning.Output(),
@@ -179,10 +179,10 @@ class SkipLayerGuidanceSD3(io.ComfyNode):
             description="Generic version of SkipLayerGuidance node that can be used on every DiT model.",
             inputs=[
                 io.Model.Input("model"),
-                io.String.Input("layers", default="7, 8, 9", multiline=False),
+                io.String.Input("layers", default="7, 8, 9", multiline=False, advanced=True),
                 io.Float.Input("scale", default=3.0, min=0.0, max=10.0, step=0.1),
-                io.Float.Input("start_percent", default=0.01, min=0.0, max=1.0, step=0.001),
-                io.Float.Input("end_percent", default=0.15, min=0.0, max=1.0, step=0.001),
+                io.Float.Input("start_percent", default=0.01, min=0.0, max=1.0, step=0.001, advanced=True),
+                io.Float.Input("end_percent", default=0.15, min=0.0, max=1.0, step=0.001, advanced=True),
             ],
             outputs=[
                 io.Model.Output(),

comfy_extras/nodes_sdupscale.py

@@ -15,7 +15,7 @@ class SD_4XUpscale_Conditioning(io.ComfyNode):
                 io.Conditioning.Input("positive"),
                 io.Conditioning.Input("negative"),
                 io.Float.Input("scale_ratio", default=4.0, min=0.0, max=10.0, step=0.01),
-                io.Float.Input("noise_augmentation", default=0.0, min=0.0, max=1.0, step=0.001),
+                io.Float.Input("noise_augmentation", default=0.0, min=0.0, max=1.0, step=0.001, advanced=True),
             ],
             outputs=[
                 io.Conditioning.Output(display_name="positive"),

comfy_extras/nodes_slg.py

@@ -21,11 +21,11 @@ class SkipLayerGuidanceDiT(io.ComfyNode):
             is_experimental=True,
             inputs=[
                 io.Model.Input("model"),
-                io.String.Input("double_layers", default="7, 8, 9"),
-                io.String.Input("single_layers", default="7, 8, 9"),
+                io.String.Input("double_layers", default="7, 8, 9", advanced=True),
+                io.String.Input("single_layers", default="7, 8, 9", advanced=True),
                 io.Float.Input("scale", default=3.0, min=0.0, max=10.0, step=0.1),
-                io.Float.Input("start_percent", default=0.01, min=0.0, max=1.0, step=0.001),
-                io.Float.Input("end_percent", default=0.15, min=0.0, max=1.0, step=0.001),
+                io.Float.Input("start_percent", default=0.01, min=0.0, max=1.0, step=0.001, advanced=True),
+                io.Float.Input("end_percent", default=0.15, min=0.0, max=1.0, step=0.001, advanced=True),
                 io.Float.Input("rescaling_scale", default=0.0, min=0.0, max=10.0, step=0.01),
             ],
             outputs=[
@@ -101,10 +101,10 @@ class SkipLayerGuidanceDiTSimple(io.ComfyNode):
             is_experimental=True,
             inputs=[
                 io.Model.Input("model"),
-                io.String.Input("double_layers", default="7, 8, 9"),
-                io.String.Input("single_layers", default="7, 8, 9"),
-                io.Float.Input("start_percent", default=0.0, min=0.0, max=1.0, step=0.001),
-                io.Float.Input("end_percent", default=1.0, min=0.0, max=1.0, step=0.001),
+                io.String.Input("double_layers", default="7, 8, 9", advanced=True),
+                io.String.Input("single_layers", default="7, 8, 9", advanced=True),
+                io.Float.Input("start_percent", default=0.0, min=0.0, max=1.0, step=0.001, advanced=True),
+                io.Float.Input("end_percent", default=1.0, min=0.0, max=1.0, step=0.001, advanced=True),
             ],
             outputs=[
                 io.Model.Output(),

comfy_extras/nodes_stable3d.py

@@ -75,8 +75,8 @@ class StableZero123_Conditioning_Batched(io.ComfyNode):
                 io.Int.Input("batch_size", default=1, min=1, max=4096),
                 io.Float.Input("elevation", default=0.0, min=-180.0, max=180.0, step=0.1, round=False),
                 io.Float.Input("azimuth", default=0.0, min=-180.0, max=180.0, step=0.1, round=False),
-                io.Float.Input("elevation_batch_increment", default=0.0, min=-180.0, max=180.0, step=0.1, round=False),
-                io.Float.Input("azimuth_batch_increment", default=0.0, min=-180.0, max=180.0, step=0.1, round=False)
+                io.Float.Input("elevation_batch_increment", default=0.0, min=-180.0, max=180.0, step=0.1, round=False, advanced=True),
+                io.Float.Input("azimuth_batch_increment", default=0.0, min=-180.0, max=180.0, step=0.1, round=False, advanced=True)
             ],
             outputs=[
                 io.Conditioning.Output(display_name="positive"),

comfy_extras/nodes_stable_cascade.py

@@ -33,7 +33,7 @@ class StableCascade_EmptyLatentImage(io.ComfyNode):
             inputs=[
                 io.Int.Input("width", default=1024, min=256, max=nodes.MAX_RESOLUTION, step=8),
                 io.Int.Input("height", default=1024, min=256, max=nodes.MAX_RESOLUTION, step=8),
-                io.Int.Input("compression", default=42, min=4, max=128, step=1),
+                io.Int.Input("compression", default=42, min=4, max=128, step=1, advanced=True),
                 io.Int.Input("batch_size", default=1, min=1, max=4096),
             ],
             outputs=[
@@ -62,7 +62,7 @@ class StableCascade_StageC_VAEEncode(io.ComfyNode):
             inputs=[
                 io.Image.Input("image"),
                 io.Vae.Input("vae"),
-                io.Int.Input("compression", default=42, min=4, max=128, step=1),
+                io.Int.Input("compression", default=42, min=4, max=128, step=1, advanced=True),
             ],
             outputs=[
                 io.Latent.Output(display_name="stage_c"),

comfy_extras/nodes_string.py

@@ -169,7 +169,7 @@ class StringContains(io.ComfyNode):
             inputs=[
                 io.String.Input("string", multiline=True),
                 io.String.Input("substring", multiline=True),
-                io.Boolean.Input("case_sensitive", default=True),
+                io.Boolean.Input("case_sensitive", default=True, advanced=True),
             ],
             outputs=[
                 io.Boolean.Output(display_name="contains"),
@@ -198,7 +198,7 @@ class StringCompare(io.ComfyNode):
                 io.String.Input("string_a", multiline=True),
                 io.String.Input("string_b", multiline=True),
                 io.Combo.Input("mode", options=["Starts With", "Ends With", "Equal"]),
-                io.Boolean.Input("case_sensitive", default=True),
+                io.Boolean.Input("case_sensitive", default=True, advanced=True),
             ],
             outputs=[
                 io.Boolean.Output(),
@@ -233,9 +233,9 @@ class RegexMatch(io.ComfyNode):
             inputs=[
                 io.String.Input("string", multiline=True),
                 io.String.Input("regex_pattern", multiline=True),
-                io.Boolean.Input("case_insensitive", default=True),
-                io.Boolean.Input("multiline", default=False),
-                io.Boolean.Input("dotall", default=False),
+                io.Boolean.Input("case_insensitive", default=True, advanced=True),
+                io.Boolean.Input("multiline", default=False, advanced=True),
+                io.Boolean.Input("dotall", default=False, advanced=True),
             ],
             outputs=[
                 io.Boolean.Output(display_name="matches"),
@@ -275,10 +275,10 @@ class RegexExtract(io.ComfyNode):
                 io.String.Input("string", multiline=True),
                 io.String.Input("regex_pattern", multiline=True),
                 io.Combo.Input("mode", options=["First Match", "All Matches", "First Group", "All Groups"]),
-                io.Boolean.Input("case_insensitive", default=True),
-                io.Boolean.Input("multiline", default=False),
-                io.Boolean.Input("dotall", default=False),
-                io.Int.Input("group_index", default=1, min=0, max=100),
+                io.Boolean.Input("case_insensitive", default=True, advanced=True),
+                io.Boolean.Input("multiline", default=False, advanced=True),
+                io.Boolean.Input("dotall", default=False, advanced=True),
+                io.Int.Input("group_index", default=1, min=0, max=100, advanced=True),
             ],
             outputs=[
                 io.String.Output(),
@@ -351,10 +351,10 @@ class RegexReplace(io.ComfyNode):
                 io.String.Input("string", multiline=True),
                 io.String.Input("regex_pattern", multiline=True),
                 io.String.Input("replace", multiline=True),
-                io.Boolean.Input("case_insensitive", default=True, optional=True),
-                io.Boolean.Input("multiline", default=False, optional=True),
-                io.Boolean.Input("dotall", default=False, optional=True, tooltip="When enabled, the dot (.) character will match any character including newline characters. When disabled, dots won't match newlines."),
-                io.Int.Input("count", default=0, min=0, max=100, optional=True, tooltip="Maximum number of replacements to make. Set to 0 to replace all occurrences (default). Set to 1 to replace only the first match, 2 for the first two matches, etc."),
+                io.Boolean.Input("case_insensitive", default=True, optional=True, advanced=True),
+                io.Boolean.Input("multiline", default=False, optional=True, advanced=True),
+                io.Boolean.Input("dotall", default=False, optional=True, advanced=True, tooltip="When enabled, the dot (.) character will match any character including newline characters. When disabled, dots won't match newlines."),
+                io.Int.Input("count", default=0, min=0, max=100, optional=True, advanced=True, tooltip="Maximum number of replacements to make. Set to 0 to replace all occurrences (default). Set to 1 to replace only the first match, 2 for the first two matches, etc."),
             ],
             outputs=[
                 io.String.Output(),

comfy_extras/nodes_toolkit.py

@@ -0,0 +1,47 @@
+from __future__ import annotations
+from typing_extensions import override
+from comfy_api.latest import ComfyExtension, io
+
+
+class CreateList(io.ComfyNode):
+    @classmethod
+    def define_schema(cls):
+        template_matchtype = io.MatchType.Template("type")
+        template_autogrow = io.Autogrow.TemplatePrefix(
+            input=io.MatchType.Input("input", template=template_matchtype),
+            prefix="input",
+        )
+        return io.Schema(
+            node_id="CreateList",
+            display_name="Create List",
+            category="logic",
+            is_input_list=True,
+            search_aliases=["Image Iterator", "Text Iterator", "Iterator"],
+            inputs=[io.Autogrow.Input("inputs", template=template_autogrow)],
+            outputs=[
+                io.MatchType.Output(
+                    template=template_matchtype,
+                    is_output_list=True,
+                    display_name="list",
+                ),
+            ],
+        )
+
+    @classmethod
+    def execute(cls, inputs: io.Autogrow.Type) -> io.NodeOutput:
+        output_list = []
+        for input in inputs.values():
+            output_list += input
+        return io.NodeOutput(output_list)
+
+
+class ToolkitExtension(ComfyExtension):
+    @override
+    async def get_node_list(self) -> list[type[io.ComfyNode]]:
+        return [
+            CreateList,
+        ]
+
+
+async def comfy_entrypoint() -> ToolkitExtension:
+    return ToolkitExtension()

comfy_extras/nodes_torch_compile.py

@@ -16,6 +16,7 @@ class TorchCompileModel(io.ComfyNode):
                 io.Combo.Input(
                     "backend",
                     options=["inductor", "cudagraphs"],
+                    advanced=True,
                 ),
             ],
             outputs=[io.Model.Output()],

comfy_extras/nodes_video.py

@@ -73,7 +73,6 @@ class SaveVideo(io.ComfyNode):
             search_aliases=["export video"],
             display_name="Save Video",
             category="image/video",
-            main_category="Basic",
             description="Saves the input images to your ComfyUI output directory.",
             inputs=[
                 io.Video.Input("video", tooltip="The video to save."),
@@ -147,7 +146,6 @@ class GetVideoComponents(io.ComfyNode):
             search_aliases=["extract frames", "split video", "video to images", "demux"],
             display_name="Get Video Components",
             category="image/video",
-            main_category="Video Tools",
             description="Extracts all components from a video: frames, audio, and framerate.",
             inputs=[
                 io.Video.Input("video", tooltip="The video to extract components from."),
@@ -176,7 +174,6 @@ class LoadVideo(io.ComfyNode):
             search_aliases=["import video", "open video", "video file"],
             display_name="Load Video",
             category="image/video",
-            main_category="Basic",
             inputs=[
                 io.Combo.Input("file", options=sorted(files), upload=io.UploadType.video),
             ],

comfy_extras/nodes_video_model.py

@@ -32,9 +32,9 @@ class SVD_img2vid_Conditioning:
                               "width": ("INT", {"default": 1024, "min": 16, "max": nodes.MAX_RESOLUTION, "step": 8}),
                               "height": ("INT", {"default": 576, "min": 16, "max": nodes.MAX_RESOLUTION, "step": 8}),
                               "video_frames": ("INT", {"default": 14, "min": 1, "max": 4096}),
-                              "motion_bucket_id": ("INT", {"default": 127, "min": 1, "max": 1023}),
+                              "motion_bucket_id": ("INT", {"default": 127, "min": 1, "max": 1023, "advanced": True}),
                               "fps": ("INT", {"default": 6, "min": 1, "max": 1024}),
-                              "augmentation_level": ("FLOAT", {"default": 0.0, "min": 0.0, "max": 10.0, "step": 0.01})
+                              "augmentation_level": ("FLOAT", {"default": 0.0, "min": 0.0, "max": 10.0, "step": 0.01, "advanced": True})
                              }}
     RETURN_TYPES = ("CONDITIONING", "CONDITIONING", "LATENT")
     RETURN_NAMES = ("positive", "negative", "latent")
@@ -60,7 +60,7 @@ class VideoLinearCFGGuidance:
     @classmethod
     def INPUT_TYPES(s):
         return {"required": { "model": ("MODEL",),
-                              "min_cfg": ("FLOAT", {"default": 1.0, "min": 0.0, "max": 100.0, "step":0.5, "round": 0.01}),
+                              "min_cfg": ("FLOAT", {"default": 1.0, "min": 0.0, "max": 100.0, "step":0.5, "round": 0.01, "advanced": True}),
                               }}
     RETURN_TYPES = ("MODEL",)
     FUNCTION = "patch"
@@ -84,7 +84,7 @@ class VideoTriangleCFGGuidance:
     @classmethod
     def INPUT_TYPES(s):
         return {"required": { "model": ("MODEL",),
-                              "min_cfg": ("FLOAT", {"default": 1.0, "min": 0.0, "max": 100.0, "step":0.5, "round": 0.01}),
+                              "min_cfg": ("FLOAT", {"default": 1.0, "min": 0.0, "max": 100.0, "step":0.5, "round": 0.01, "advanced": True}),
                               }}
     RETURN_TYPES = ("MODEL",)
     FUNCTION = "patch"

comfy_extras/nodes_wan.py

@@ -717,8 +717,8 @@ class WanTrackToVideo(io.ComfyNode):
                 io.Int.Input("height", default=480, min=16, max=nodes.MAX_RESOLUTION, step=16),
                 io.Int.Input("length", default=81, min=1, max=nodes.MAX_RESOLUTION, step=4),
                 io.Int.Input("batch_size", default=1, min=1, max=4096),
-                io.Float.Input("temperature", default=220.0, min=1.0, max=1000.0, step=0.1),
-                io.Int.Input("topk", default=2, min=1, max=10),
+                io.Float.Input("temperature", default=220.0, min=1.0, max=1000.0, step=0.1, advanced=True),
+                io.Int.Input("topk", default=2, min=1, max=10, advanced=True),
                 io.Image.Input("start_image"),
                 io.ClipVisionOutput.Input("clip_vision_output", optional=True),
             ],
@@ -1323,7 +1323,7 @@ class WanInfiniteTalkToVideo(io.ComfyNode):
                 io.ClipVisionOutput.Input("clip_vision_output", optional=True),
                 io.Image.Input("start_image", optional=True),
                 io.AudioEncoderOutput.Input("audio_encoder_output_1"),
-                io.Int.Input("motion_frame_count", default=9, min=1, max=33, step=1, tooltip="Number of previous frames to use as motion context."),
+                io.Int.Input("motion_frame_count", default=9, min=1, max=33, step=1, tooltip="Number of previous frames to use as motion context.", advanced=True),
                 io.Float.Input("audio_scale", default=1.0, min=-10.0, max=10.0, step=0.01),
                 io.Image.Input("previous_frames", optional=True),
             ],

comfy_extras/nodes_wanmove.py

@@ -252,9 +252,9 @@ class WanMoveVisualizeTracks(io.ComfyNode):
                 io.Image.Input("images"),
                 io.Tracks.Input("tracks", optional=True),
                 io.Int.Input("line_resolution", default=24, min=1, max=1024),
-                io.Int.Input("circle_size", default=12, min=1, max=128),
+                io.Int.Input("circle_size", default=12, min=1, max=128, advanced=True),
                 io.Float.Input("opacity", default=0.75, min=0.0, max=1.0, step=0.01),
-                io.Int.Input("line_width", default=16, min=1, max=128),
+                io.Int.Input("line_width", default=16, min=1, max=128, advanced=True),
             ],
             outputs=[
                 io.Image.Output(),

comfy_extras/nodes_zimage.py

@@ -16,7 +16,7 @@ class TextEncodeZImageOmni(io.ComfyNode):
                 io.Clip.Input("clip"),
                 io.ClipVision.Input("image_encoder", optional=True),
                 io.String.Input("prompt", multiline=True, dynamic_prompts=True),
-                io.Boolean.Input("auto_resize_images", default=True),
+                io.Boolean.Input("auto_resize_images", default=True, advanced=True),
                 io.Vae.Input("vae", optional=True),
                 io.Image.Input("image1", optional=True),
                 io.Image.Input("image2", optional=True),

comfyui_version.py

@@ -1,3 +1,3 @@
 # This file is automatically generated by the build process when version is
 # updated in pyproject.toml.
-__version__ = "0.12.2"
+__version__ = "0.12.3"

nodes.py

@@ -69,7 +69,6 @@ class CLIPTextEncode(ComfyNodeABC):
     FUNCTION = "encode"
 
     CATEGORY = "conditioning"
-    MAIN_CATEGORY = "Basic"
     DESCRIPTION = "Encodes a text prompt using a CLIP model into an embedding that can be used to guide the diffusion model towards generating specific images."
     SEARCH_ALIASES = ["text", "prompt", "text prompt", "positive prompt", "negative prompt", "encode text", "text encoder", "encode prompt"]
 
@@ -321,10 +320,10 @@ class VAEDecodeTiled:
     @classmethod
     def INPUT_TYPES(s):
         return {"required": {"samples": ("LATENT", ), "vae": ("VAE", ),
-                             "tile_size": ("INT", {"default": 512, "min": 64, "max": 4096, "step": 32}),
-                             "overlap": ("INT", {"default": 64, "min": 0, "max": 4096, "step": 32}),
-                             "temporal_size": ("INT", {"default": 64, "min": 8, "max": 4096, "step": 4, "tooltip": "Only used for video VAEs: Amount of frames to decode at a time."}),
-                             "temporal_overlap": ("INT", {"default": 8, "min": 4, "max": 4096, "step": 4, "tooltip": "Only used for video VAEs: Amount of frames to overlap."}),
+                             "tile_size": ("INT", {"default": 512, "min": 64, "max": 4096, "step": 32, "advanced": True}),
+                             "overlap": ("INT", {"default": 64, "min": 0, "max": 4096, "step": 32, "advanced": True}),
+                             "temporal_size": ("INT", {"default": 64, "min": 8, "max": 4096, "step": 4, "tooltip": "Only used for video VAEs: Amount of frames to decode at a time.", "advanced": True}),
+                             "temporal_overlap": ("INT", {"default": 8, "min": 4, "max": 4096, "step": 4, "tooltip": "Only used for video VAEs: Amount of frames to overlap.", "advanced": True}),
                             }}
     RETURN_TYPES = ("IMAGE",)
     FUNCTION = "decode"
@@ -368,10 +367,10 @@ class VAEEncodeTiled:
     @classmethod
     def INPUT_TYPES(s):
         return {"required": {"pixels": ("IMAGE", ), "vae": ("VAE", ),
-                             "tile_size": ("INT", {"default": 512, "min": 64, "max": 4096, "step": 64}),
-                             "overlap": ("INT", {"default": 64, "min": 0, "max": 4096, "step": 32}),
-                             "temporal_size": ("INT", {"default": 64, "min": 8, "max": 4096, "step": 4, "tooltip": "Only used for video VAEs: Amount of frames to encode at a time."}),
-                             "temporal_overlap": ("INT", {"default": 8, "min": 4, "max": 4096, "step": 4, "tooltip": "Only used for video VAEs: Amount of frames to overlap."}),
+                             "tile_size": ("INT", {"default": 512, "min": 64, "max": 4096, "step": 64, "advanced": True}),
+                             "overlap": ("INT", {"default": 64, "min": 0, "max": 4096, "step": 32, "advanced": True}),
+                             "temporal_size": ("INT", {"default": 64, "min": 8, "max": 4096, "step": 4, "tooltip": "Only used for video VAEs: Amount of frames to encode at a time.", "advanced": True}),
+                             "temporal_overlap": ("INT", {"default": 8, "min": 4, "max": 4096, "step": 4, "tooltip": "Only used for video VAEs: Amount of frames to overlap.", "advanced": True}),
                             }}
     RETURN_TYPES = ("LATENT",)
     FUNCTION = "encode"
@@ -655,7 +654,7 @@ class CLIPSetLastLayer:
     @classmethod
     def INPUT_TYPES(s):
         return {"required": { "clip": ("CLIP", ),
-                              "stop_at_clip_layer": ("INT", {"default": -1, "min": -24, "max": -1, "step": 1}),
+                              "stop_at_clip_layer": ("INT", {"default": -1, "min": -24, "max": -1, "step": 1, "advanced": True}),
                               }}
     RETURN_TYPES = ("CLIP",)
     FUNCTION = "set_last_layer"
@@ -668,8 +667,6 @@ class CLIPSetLastLayer:
         return (clip,)
 
 class LoraLoader:
-    MAIN_CATEGORY = "Image Generation"
-
     def __init__(self):
         self.loaded_lora = None
 
@@ -1597,7 +1594,7 @@ class KSamplerAdvanced:
     def INPUT_TYPES(s):
         return {"required":
                     {"model": ("MODEL",),
-                    "add_noise": (["enable", "disable"], ),
+                    "add_noise": (["enable", "disable"], {"advanced": True}),
                     "noise_seed": ("INT", {"default": 0, "min": 0, "max": 0xffffffffffffffff, "control_after_generate": True}),
                     "steps": ("INT", {"default": 20, "min": 1, "max": 10000}),
                     "cfg": ("FLOAT", {"default": 8.0, "min": 0.0, "max": 100.0, "step":0.1, "round": 0.01}),
@@ -1606,9 +1603,9 @@ class KSamplerAdvanced:
                     "positive": ("CONDITIONING", ),
                     "negative": ("CONDITIONING", ),
                     "latent_image": ("LATENT", ),
-                    "start_at_step": ("INT", {"default": 0, "min": 0, "max": 10000}),
-                    "end_at_step": ("INT", {"default": 10000, "min": 0, "max": 10000}),
-                    "return_with_leftover_noise": (["disable", "enable"], ),
+                    "start_at_step": ("INT", {"default": 0, "min": 0, "max": 10000, "advanced": True}),
+                    "end_at_step": ("INT", {"default": 10000, "min": 0, "max": 10000, "advanced": True}),
+                    "return_with_leftover_noise": (["disable", "enable"], {"advanced": True}),
                      }
                 }
 
@@ -1651,7 +1648,6 @@ class SaveImage:
     OUTPUT_NODE = True
 
     CATEGORY = "image"
-    MAIN_CATEGORY = "Basic"
     DESCRIPTION = "Saves the input images to your ComfyUI output directory."
     SEARCH_ALIASES = ["save", "save image", "export image", "output image", "write image", "download"]
 
@@ -1710,7 +1706,6 @@ class LoadImage:
                 }
 
     CATEGORY = "image"
-    MAIN_CATEGORY = "Basic"
     SEARCH_ALIASES = ["load image", "open image", "import image", "image input", "upload image", "read image", "image loader"]
 
     RETURN_TYPES = ("IMAGE", "MASK")
@@ -1868,7 +1863,6 @@ class ImageScale:
     FUNCTION = "upscale"
 
     CATEGORY = "image/upscaling"
-    MAIN_CATEGORY = "Image Tools"
     SEARCH_ALIASES = ["resize", "resize image", "scale image", "image resize", "zoom", "zoom in", "change size"]
 
     def upscale(self, image, upscale_method, width, height, crop):
@@ -1908,7 +1902,6 @@ class ImageScaleBy:
 
 class ImageInvert:
     SEARCH_ALIASES = ["reverse colors"]
-    MAIN_CATEGORY = "Image Tools"
 
     @classmethod
     def INPUT_TYPES(s):
@@ -1925,7 +1918,6 @@ class ImageInvert:
 
 class ImageBatch:
     SEARCH_ALIASES = ["combine images", "merge images", "stack images"]
-    MAIN_CATEGORY = "Image Tools"
 
     @classmethod
     def INPUT_TYPES(s):
@@ -1982,7 +1974,7 @@ class ImagePadForOutpaint:
                 "top": ("INT", {"default": 0, "min": 0, "max": MAX_RESOLUTION, "step": 8}),
                 "right": ("INT", {"default": 0, "min": 0, "max": MAX_RESOLUTION, "step": 8}),
                 "bottom": ("INT", {"default": 0, "min": 0, "max": MAX_RESOLUTION, "step": 8}),
-                "feathering": ("INT", {"default": 40, "min": 0, "max": MAX_RESOLUTION, "step": 1}),
+                "feathering": ("INT", {"default": 40, "min": 0, "max": MAX_RESOLUTION, "step": 1, "advanced": True}),
             }
         }
 
@@ -2441,7 +2433,8 @@ async def init_builtin_extra_nodes():
         "nodes_image_compare.py",
         "nodes_zimage.py",
         "nodes_lora_debug.py",
-        "nodes_color.py"
+        "nodes_color.py",
+        "nodes_toolkit.py",
     ]
 
     import_failed = []

pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "ComfyUI"
-version = "0.12.2"
+version = "0.12.3"
 readme = "README.md"
 license = { file = "LICENSE" }
 requires-python = ">=3.10"

requirements.txt

@@ -1,4 +1,4 @@
-comfyui-frontend-package==1.37.11
+comfyui-frontend-package==1.38.13
 comfyui-workflow-templates==0.8.31
 comfyui-embedded-docs==0.4.0
 torch

server.py

@@ -687,10 +687,6 @@ class PromptServer():
                 info['api_node'] = obj_class.API_NODE
 
             info['search_aliases'] = getattr(obj_class, 'SEARCH_ALIASES', [])
-
-            if hasattr(obj_class, 'MAIN_CATEGORY'):
-                info['main_category'] = obj_class.MAIN_CATEGORY
-
             return info
 
         @routes.get("/object_info")