I mostly used claude to build Openjutsu, a free, local version of Higgsfield’s Genjutsu character swap, for Comfy’s Open Source Higgsfield challenge.

Repo (MIT): https://github.com/D3voz/openjutsu

What it does
Upload a video and a picture of the person you want in it, then press Run. It finds the person, swaps them in clip by clip and keeps the original audio. There are also modes for:

• Object swap (change or remove an object, or change the background)
• From picture (put a person and a setting from one image into a video)
• Fix faces and Fix colours as post-processing

How it’s built

• A Next.js web app that talks to ComfyUI through u/comfyorg/sdk and comfy-api-proxy
• MiniMax H3 does the video generation
• Qwen3-VL 8B looks at the frames and writes the prompts automatically
• SAM makes a mask of the person in each clip
• Long videos are split into overlapping clips and joined back together

Setup
Install the custom nodes and models listed in the README, start ComfyUI, then double-click start_openjutsu.bat. Before each run, the app checks that you have every node and model it needs. If something is missing, it tells you where to get it.

Feedback and bug reports are welcome!

If you are getting any errors-

1. Update comfyui-h3-oneclick-swap.
2. git pull Openjutsu.
3. Restart ComfyUI so it loads the new node, then restart Openjutsu.

I always thought this model was AMAZING! But I'm not sure if my workflows, my prompts and my creativity can get the best out of it. So I want you guys to show me the generations you are most proud of. Let's make this a quality gallery for the community. Here are mine ( Upscaled with RealESRGAN_x4plus.pth )

Prompts: https://pastebin.com/yjrkc5ne

I randomly came across this project on Lemmy's Stable Diffusion community and thought it was worth sharing here. Just to be clear, I'm not affiliated with the developers or the project in any way. I simply stumbled upon it, and I couldn't find any discussion about it on Reddit.

 The model is called VitronEdit, and its paper was published on October 19, 2026.

 What caught my attention is that it attempts to bring image editing, video editing, and 3D scene editing into a single unified framework, rather than treating them as completely separate tasks.

 According to the researchers, VitronEdit supports:

 - Image editing: Modify images using text instructions, optionally with reference images.

- Video editing: Edit existing videos using text instructions, with optional reference-image conditioning.

- 3D scene editing: Apply edits across multiple viewpoints while maintaining geometric consistency.

- Cross-modal learning: Transfer editing knowledge learned from images and videos to 3D scenes.

- Geometry-aware training: Use depth and camera-pose supervision to improve structural and multi-view consistency.

 One particularly interesting finding in the paper is that applying geometric supervision exclusively to 3D training samples also improved image and video editing performance.

 The project page has visual demonstrations of all three editing modes, including object transformations and multi-view scene editing.

 Links:

 - Project page and demos: https://vitron-llm.github.io/VitronEdit/

- Research paper: https://arxiv.org/abs/2610.27049

- GitHub (code): https://github.com/Vitron-LLM/VitronEdit-Code

- Hugging Face (weights): https://huggingface.co/SanRiiiii/VitronEdit

- Original Lemmy post where I discovered it: https://lemmy.world/post/53470733

The code and model weights are available, although this appears to be a research-oriented release rather than a ready-to-use Stable Diffusion or ComfyUI workflow.

 I haven't tested it myself, so I can't comment on real-world performance, hardware requirements, or how well the demonstrated results generalize.

 Still, the idea of combining image, video, and 3D editing in one framework seems interesting, especially if the community eventually develops easier local inference workflows.

 Has anyone here tried running it locally? I'd be particularly interested in hearing about VRAM requirements, inference speed, and whether anyone is working on ComfyUI integration.

Note: I used AI to proofread and correct errors in this post.

Epoch 20 was reached early this morning. I have released the following models:

1. Raw

2. Raw EMA 0.9995

3. Raw EMA 0.99975

4. Turbo

5. Turbo EMA 0.9995

6. Turbo EMA 0.99975

7. Extracted LoRA models (rank 64, 128, and 256) for all the models above.

All models are released in both diffusers and comfy format.

The EMA models might be slighter higher quality do to smoothing, but may also be less performant in terms of BBOXes.

The raw models are provided for training purposes and should allow you to train multi-character LoRAs, following the formatting given in the prompting guide.

I have not tried multi-character LoRA yet, but given Ideogram4, it should be easily possible.

The models are available at:

https://huggingface.co/jimmycarter/krea2-turbo-bbox

The latest checkpoint of the turbo model is available for free to try on huggingface spaces:

https://huggingface.co/spaces/jimmycarter/krea2-turbo-bbox-canvas

This release includes added RoPE Scaling support to MOSS-Image, support for MOSS-Image color-depth control, support for MOSS-Image-Edit LoRAs, added Fibo 2.0 support, a change from RoPE Scaling to NTK-aware (for Fibo 2.0), and a fix for Fibo 2.0 text-to-image negative prompt handling, among other fixes/improvements.

SenseNova 6.8 Code2Video is here, a model that creates videos by writing code, just like Claude Opus 5.5
Its focus includes motion graphics, kinetic typography, animated illustrations, product presentations, and visual explainers
Main features:
Video through code. Describe what you want, and the model writes code to create the video.

Natural-language editing. Request changes to colors, timing, motion, or scene elements after the first version.

Reference-video reconstruction. Rebuild a reference video’s layout and motion as editable code, then make changes.

Motion graphics and more. Suited to kinetic typography, animated illustrations, product presentations, and visual explainers.

A creation Skill. Guides the process from an initial idea to a detailed brief, preview, and revision.

Model weights and Skill. Both are included in the release plan. INT4 and INT8 weights are planned for later.

GitHub:
https://github.com/OpenSenseNova/SenseNova-6.8-Code2Video
Model:
https://huggingface.co/sensenova/SenseNova-6.8-Code2Video

There are a thousand minimax workflow, and while each serve their purpose, I’ve yet to find one that produces the same near-lossless or cinematic quality output I’ve seen others post here. Almost every workflow uses 8 steps and/or Patch Sage Attention, Model Attention Backend, H3 Memory Optimization, etc, which ultimately hurt the output. I have tried 20, 25, 30 steps — and while they’re good, they’re not great.

I have used LM Studio to build my prompts, which has drastically improved the adherence and flow, but the quality still isn’t there. I have tried resolution ranging from .5 - 1.5, marginally impacts quality but hinders adherence when above 1.1.

Assuming a clapped out system with a 5090 or renting a pod with bigger specs, is there a key workflow to use that focuses on output quality, speed be damned?

Flux2 Klein only reads three hidden layers from its Qwen3 text encoder (9, 18 and 27), but the standard loaders build and run the full 36-layer model, plus the final norm and the LM head. On top of that, ComfyUI-GGUF dequantizes the whole token embedding table to fp16 when it loads the GGUF.

I made a small loader that only builds what Klein actually uses:

• 27 layers instead of 36, no final norm, no LM head
• GGUF token embeddings stay quantized: only the rows of your prompt are dequantized
• Same conditioning, bit for bit (compared against CLIPLoader (GGUF), max abs diff 0.0)

Numbers (Qwen3-8B Q4_K_M, Klein 9B, RTX 4090, 512-token prompt):

That's ~2.3 GB back for the DiT, a LoRA stack, or an LLM running next to ComfyUI. On an 8 GB card it can be the difference between offloading or not.

Install:

cd ComfyUI/custom_nodes
git clone https://github.com/dchatel/comfyui_davcha_flux2klein

Then swap your text encoder loader for Klein CLIP Loader (Pruned) (category davcha/flux2klein). GGUF files need ComfyUI-GGUF installed. No other dependencies.

Tested with Qwen3-8B Q4_K_M (Klein 9B). The Qwen3-4B (Klein 4B) and safetensors paths use the same settings but I haven't verified them myself yet. Reports welcome.

Repo: https://github.com/dchatel/comfyui_davcha_flux2klein

Side note: while profiling this I also noticed ComfyUI picks which model to unload by reference count and size, not by how long the model takes to reload. I opened a PR that ranks unload candidates by measured reload time instead (13.6 s → 6.7 s per run in a Klein + local LLM workflow): https://github.com/Comfy-Org/ComfyUI/pull/17363 (not merged, feedback welcome).

Hey! We published a set of 6-step LoRAs, one without the upsampling step: https://huggingface.co/PrunaAI/P-Q-Image-2.1

- Generate or edit images in just 6 steps instead of 40. Use 6-steps for preserving inputs when editing and 6-steps-upsampled for improved visual quality and shorter end-to-end generation.
- 6-step distillation provides improved quality with few generation steps.6-steps-upsampled is the first distillation that removes the need for a separate prompt-upsampling step. This means 41 to 80 seconds saved, depending on your prompt style.
- The LoRA adapters load directly on top of Qwen-Image-2.1, so the pipeline stays unchanged. Few-step distillation cuts the diffusion cost, and the upsampled adapter also removes the prompt-upsampling step before image generation.

Claude code + r2v MINIMAX H3 and some loras + casual prompt like "this shit is not good make it better" My goal is make a 2-5 fucking dinamic anime, but i dont like anime

For anyone interested, here's the current workflow I'm using to make this AI anime.

Hardware & Setup

• RunPod with an RTX 4090 (24GB VRAM)
• ComfyUI 0.42.0
• Custom Python automation script (h3_ctrl.py)

1. Character Design & Keyframes

• Model: Krea 2 Turbo (INT8)
• Text Encoder: Qwen3VL 4B
• LoRA: Kegant V5 (1.0) for that dark, mystical anime aesthetic
• 8–10 steps, CFG 1, Euler/Simple
• Around 12 seconds per image

I generate character reference sheets and keyframes for each scene, including the starting frame and the exact impact frame.

2. Video Generation

• Model: MiniMax H3 Hybrid FL2VA + REF2VA (INT8)
• Text Encoder: Qwen3VL 32B
• Resolution: 1344×768, 24 FPS
• Duration: 5 seconds per clip, with generated audio

LoRA stack:

• Turbo 8-Step (LightX2V): speed and sharpness
• H3 Combat V2: fighting, impacts and dramatic action
• BUNNY Motion Repair V2: smoother continuous movement
• SuperHunman: stronger, more powerful motion
• Action Speed + Acceleration sliders: both at 3.0

3. The Workflow

I'm using a modified BUNNY two-pass approach:

• First pass generates the main movement using the LoRA stack.
• Second pass refines details and impacts.
• 10 sampling steps + 4 additional steps for motion formation.
• res_multistep sampler.

Character sheets go into MiniMaxH3ReferenceToVideo, while MiniMaxH3AddGuide anchors the starting frame and impact frame (around frame 72–77).

Prompts are structured into six sections, including detailed character descriptions, continuity constraints, second-by-second action choreography, and sound effects.

4. Connecting Multiple Clips

I'm experimenting with H3 Motion Context by NikoDemon80 to extend scenes beyond 5 seconds.

It takes the last 22 frames of the previous clip as context for the next generation, then removes the overlapping frames when joining everything together.

The goal is longer action sequences with consistent characters and continuous motion.

5. A Few Important Details

• No custom-trained character LoRAs.
• I manually check keyframes for costume consistency, enemy counts and character details.
• No artificial speed-ups or slow-motion effects in editing.
• H3 generates the audio too.

And yes, Claude is involved in the process, helping orchestrate the workflow and automation.

Still very experimental. Getting consistent, high-speed anime combat is surprisingly difficult, but the results are getting better.

Hope this helps anyone experimenting with H3! 🔥

Everything you just watched was made with open-source models in ComfyUI: images and video from open-source models, sound from ElevenLabs. No camera, no actress. Mariem, her kitchen, her balcony: all generated. I'm sharing it here as a showcase, not as the real promo for my masterclass "ComfyUI... Finally Simple!"

Here is an NAR LoRA for YuE2 that I generated yesterday, CC0 if anyone is interested in using it: https://huggingface.co/jamespetts/yue2-1980s-eurodisco-lora

Hello guys, hoping you're doing fine. Wall of text next I know, but I want to get this info out of my chest, all hand written lol.

I wanted to make this post explaining some things about GPU unlocks that have been going on lately.

What are these GPU unlocks doing?

NVIDIA on purpose neuters tensor core performance when using FP32 accumulation (FP16, BF16, FP8 and TF32 inputs accumulating in FP32, which is what most AI/LLM/ML tasks use), for market segmentation. Normal FP32 on the CUDA cores (no tensor cores) is NOT affected.

Consumer and prosumer GPUs use the exact same die (like GB202 between the 5090 and 6000 PRO, AD102 between the 4090 and 6000 Ada, or even literally 1:1 with the 3090 Ti vs A6000, both with the same core amounts and 84 SMs).

How it works: the speed of each kind of tensor operation is set by fuses burned at the factory. On consumer cards, the fuse for "FP16/BF16 with FP32 accumulation" says HALF_SPEED, on the pro cards it says FULL_SPEED. These fuses don't cut any circuit, the GPU just reads them at boot and runs at that speed. The GPU also has an override register that can set them back to FULL_SPEED, but it's locked so only NVIDIA's most privileged firmware can write to it, not your PC.

The unlocks open that lock and write FULL_SPEED on the override. With that, the consumer cards gain all the neutered performance imposed by NVIDIA. It doesn't give you more SMs, VRAM or anything like that, a 4090 is still a 4090, it just runs those instructions at the same rate a pro card does.

Why can Turing, Ampere and Ada be unlocked? And what is unlocked on these cards?

On these generations, the NVIDIA driver itself loads a small NVIDIA-signed firmware called the "Booter" onto a security microcontroller inside the GPU (SEC2, a "Falcon"), to start the GSP. The Booter runs in the highest privilege mode of the GPU (Heavy Secure, HS), which is exactly the one allowed to open the lock.

In June 2026, Jon Pry published a paper ("A Canary in the Crypto Mine") showing that the Booter of the newer drivers has a buffer overflow: it copies its "signature" data using a length that you control, so you can overflow its stack (including the stack canary that is supposed to stop exactly this) and take control of the Booter while it is running in HS mode. The signature check still passes, because it is NVIDIA's own signed code running, the bug is inside it.

With that, the unlock reuses instructions from NVIDIA's own Booter to open the lock, writes FULL_SPEED on the override, resets the card and lets the normal NVIDIA driver load. The unlock survives resets and driver reloads, but it's lost when you power off, which is why it runs on every boot before the NVIDIA driver loads.

This was first done on mining cards (CMP 170HX: FP32 from 1/32 to full speed, and 10GB to 80GB of VRAM), and then ported to GeForce:

• Turing: https://github.com/haohervchb/Turing-unlock (UEFI, Linux)
• Ampere: https://github.com/Zagitta/gpu-unlock (Linux kernel module)
• Ada: https://github.com/JustAResearcher/gpu-unlock-ada (Linux with kernel module)

What gets unlocked:

• FP16 with FP32 accumulation (Turing, Ampere, Ada)
• BF16 with FP32 accumulation (Ampere, Ada; Turing has no BF16)
• TF32 (Ampere, Ada)
• FP8 with FP32 accumulation (Ada; Turing and Ampere have no FP8)

Some numbers from those repos: 4090 FP16/BF16 with FP32 acc goes from 165 to 331 TFLOPS (raw instruction rate), 3090 Ti BF16 GEMM from 87 to 157 TFLOPS, 2080 Ti FP16 with FP32 acc from 47 to 94 TFLOPS. Real-world GEMMs gain less than 2x because the cards then hit their power limit (more on that below).

Why can't consumer Blackwell be unlocked?

The funny part is that on Blackwell the limitation is EXACTLY the same thing: same fuses, same override registers. I checked on my own cards: the 5090/5080/5070 Ti have the FP32 accumulation fuses set, and the 6000 PRO/4000 PRO don't. So it's not a hardware difference there either.

What changed is the door. Starting with Hopper, and consumer Blackwell too, the root of trust of the GPU is the FSP (Foundation Security Processor), a RISC-V core that boots from its own ROM as soon as the GPU powers on, before the driver even loads. On Blackwell:

• There's no Booter to abuse. The driver just sends the FSP a message with a hash + RSA-3K signature of the next firmware, and the FSP verifies and boots it. The Linux kernel docs literally say: "There is no SEC2 involvement, no Booter ucode, and no FWSEC-FRTS stage". I also checked it myself: in NVIDIA's 615 driver source the Booter only exists for Turing, Ampere and Ada (TU102, TU116, GA100, GA102, AD102), and the RTX 50 VBIOSes don't carry the Falcon firmware (FWSEC) that older cards did.
• The firmware the driver ships for Blackwell is encrypted, and the debug and production images are the exact same encrypted bytes. The Ada payload was built from analysis of the decrypted debug Booter, on Blackwell there's no such shortcut.
• NVIDIA has said it uses SPARK (a formally verifiable programming language) to prove its most critical RISC-V firmware free of runtime errors, and a buffer overflow like the one used on the older cards is exactly that kind of error.

So, with what is known today, it can't be done. It isn't "impossible forever", but someone would need a brand new vulnerability in a way harder target. And if someone ever gets there, the unlock itself would very likely be the same couple of register writes.

FP4 is not affected, but all the rest is (FP16/BF16/FP8/TF32 with FP32 accumulation).

In which tasks is the unlock has most of the effect?

I will put some examples on my 6000 PRO vs 5090s, former using 400W and latter 600W, at how much is the impact in performance because the NVIDIA neutering.

• Training: Like LoRAs, finetuning, etc.
  • Example: Using the same batch size for 25GB VRAM to train a diffusion LoRA, my 6000 PRO is 70-90% faster than my 5090.
• Diffusion: Models that do txt2img, txt2vid, img2img, img2vid, txt2aud, etc.
  • Example: My 6000 PRO not using fp16 accumulation is about 30-40% faster than my 5090. If using fp16 accumulation, it is 15% faster.
• Prefill on LLMs: Heavily affected as well, since even when a model is marked as "int8" or "mixed precision" etc, the inference parts that the GPU uses include FP32 accumulation parts, except if explicitly set to not use them.
  • Example: My 6000 PRO on vLLM on a model that fits on a 5090 as well, it's 50-70% faster. On llamacpp, instead is about 30-40% faster.
• TG with big batching: TG with a single batch is mostly bandwidth bound, and it uses FP32 acc instructions, but since it is so little in comparison with the need of bandwidth, it isn't a limitation. On the other hand, when you use batches with batch size 2, 4, 8, etc, compute again starts to being a bottleneck and then you have a performance impact.
  • Example: Same results as previous point.

In which tasks the unlocks makes no difference:

• TG with batch size 1: almost entirely bandwidth bound.
• CUDA compute without tensor cores (normal FP32).
• INT4/INT8 tensor operations.
• FP4 on Blackwell (not neutered to begin with).
• GEMM operations with FP16 accumulation instead, but those aren't very used.
• Gaming.

Is there a risk by unlocking the cards, like burning the card, crashes, etc? Short answer: NO.

And again, NO. For the love of god guys, stop repeating this nonsense.

The cards are still limited by their max power limit. They won't magically use 200% of your power budget with an unlock, they will just use the cores more efficiently.

Let me explain: if you have a 3090 power limited at 300W, and without the unlock you were seeing only 250W in use, but after the unlock it uses 300W, it's not because the unlock did malicious things to your card. It's because the card can NOW stretch its legs and use the power to do more work. Real example from the Ada repo: an unlocked 4090 doing the same GEMMs peaked at 346W vs 313W stock, still under its 450W limit.

If you were getting X performance at Y < max TDP, and now you get more than X performance at max TDP, obviously the card will be hotter, but that's still inside the POWER LIMIT YOU SET, not above it.

Power spikes: those are normal on every card, and if you're using it to the full extent of its capabilities they can be more common. Are they risky? No, assuming you have a PSU with the wattage NVIDIA recommends per GPU.

So what ARE the actual risks then? They're about the unlock process, not your card:

• It runs an exploit on NVIDIA's firmware before the driver loads. If something fails mid-way, the tools stop and you need a full power off before trying again (a reboot isn't enough). Read the repo instructions, especially on laptops and multi-GPU setups.
• NVIDIA could patch it in future drivers, or even burn anti-rollback fuses so the old Booter stops being accepted. That wouldn't damage your card, it would just close the door for good.

"But, NVIDIA bins the dies to make these work 24/7 on the prosumer side but not on consumer, that's why they're locked!!!11"

Also incorrect. NVIDIA uses the EXACT SAME dies for their consumer GPUs and their prosumer GPUs, and the FP32 accumulation speed has nothing to do with binning: the 3090 Ti and the A6000 have the exact same specs. The half speed is just a value written in a fuse that the firmware reads.

Unlocking a card will not make it die sooner, nor will it crack the die or something.

Sorry I have to repeat this again and again, but the amount of pure fury I get from reading comments like these made me do this.

Does affect gaming performance?

None known at the moment, except if somehow NVIDIA uses FP32 accumulation for DLSS or FG, which I doubt. I'm almost sure they use FP16 accumulation (or lower precisions) there, because if they used FP32 accumulation the perf hit would be insane on consumer cards.

The model I run says it is Q8, or FP6, or 4bit, or INT4, or anything that doesn't mention FP32, am I affected?

It depends on how the GPU actually does the math, not on the name of the quant:

• If the kernel dequantizes the weights to FP16/BF16 and multiplies on the tensor cores with FP32 accumulation, you're affected. That's the case for FP16/BF16 models and most vLLM paths, including AWQ/GPTQ with Marlin kernels (the weights are INT4, but the math is FP16 with FP32 accumulation).
• FP8 (W8A8) also accumulates in FP32, so it's affected too (Ada and Blackwell).
• If the kernel uses integer tensor math (INT8 x INT8), it isn't affected. A lot of llama.cpp's quantized matmuls work like this, which is one reason llama.cpp sees a smaller gap than vLLM.
• Attention (like FlashAttention) almost always uses FP16/BF16 with FP32 accumulation, so long contexts get hit even on quantized models.
• FP4 (NVFP4/MXFP4) on Blackwell: not affected.

Example: on a modded 48GB 4090, a quantized MoE model on an inference server got no gain at all after the unlock (0.98x on 8K prefill), while the FP16/BF16 matmuls doubled.

That's what I have for now, if you guys have any more questions, let me know!

What a great model it was, totally crushed Qwen Image (its most competitive predecessor at realism) with only 6b Parameters!

Is it weird to feel nostalgic of a model release lol

So ive been testing moss the last few days, curious about how easy it is to prompt, but somehow i did not even get close to the level of detail and quality krea 2 can dish out.

Like an image done with a krea 2 turbo model with 2 passes on 8 steps has so much more finer details like skin pores, detailed eyes, cloth textures etc. than a 50 step raw model gen with a qwen 2.1 upscale afterwards.

I mean moss images look fine as thumbnails and such but in my testing so far to use them as full on wallpapers moss just struggles with quality.

Do you think this is something that will be "fixed" or can be improved on later or is that just not a good use case for moss in general? What are you experiences so far and opinions on this?

This is the first model I've seen with such control over its generation. Mind you, I haven't tried them all, but I'm confident nothing else comes close.

Hats off to the team for their hard work and for open-sourcing it.

-------------------------

Below is an image showcasing the Layout-to-Image generation that drew me in. Essentially, you define regions as objects or text and compose your ideas into a single generation.

It's easy to make modifications for ex, moving, adding, or removing characters, or layering additional concepts within the image, add text with any specific font.

Here I simply moved the characters around, placing the title on the left. It took me just a couple of seconds and changed the composition entirely.

Now, for this particular case, I could probably come close to something like this with four unique generations and overlaying a real text font. But the problem arises from other models when you want interactivity between the characters and the scene.

Here you can see the characters interacting with each other.

I can later add Guts big iconic sword.

All in all, pretty cool.

And, if you guys have other tricks for inpainting or keeping character consistency, I'm all ears.

Song (Souna login required): https://www.souna.app/song/e31cc6eb-90fe-4f58-a885-8480808e17ed

Song (alt. link): https://ia601602.us.archive.org/10/items/ai-eurodisco/Sequin%20Ball.mp3 (CC0)

This is my second Eurodisco song using my 1980s Eurodisco LoRA. It is about a glamorous pangolin.

Here is the AI's record of the production process, which should be repeatable.

=== STYLE PROMPT ===

eurodisco, English, 1983-87, glamorous, camp, D natural minor, 126 BPM, thick chorused synth bass, 4/4, LinnDrum with handclaps and gated toms, stacked synth pads and bright arpeggiated synths, dramatic synth strings and brass stabs, shimmering open hi-hats, smooth male tenor lead with clear diction, falsetto chorus lifts, mixed backing vocals with oh-oh-oh chants answering the hook in call-and-response, restrained stepwise verses building into a huge hypnotic chorus hook with wide ascending vocal leaps, bridge dips sparse then surges back, Dm-Bb-C-Dm and Dm-Gm-C-F chord loops, A7 to Dm pushes, 80s studio gloss. No EDM, no sidechaining.

=== LYRICS (as written - the text of record) ===

[Intro]

(instrumental)

Oh-oh-oh-oh

Oh-oh-oh-oh

Make way for the Sequin Ball

Pangolin means roller, I'm the ball

[Verse 1]

Midnight, solo, out on patrol

Two-leg strut, my tail props the stroll

These eyes are dim, that's right

This nose knows the way tonight

Claws out for the termite mound

Dinner's served when I tear it down

Here comes the swarm in evening clothes

I shut my ears, I shut my nose

[Chorus]

Sequin Ball

Oh-oh-oh-oh

When I roll up, I'm having a ball

Oh-oh-oh-oh

Plate on plate, I grew it alone

Oh-oh-oh-oh

Every sequin's home-grown

Oh-oh-oh-oh

Every night I take the stage

Oh-oh-oh-oh

I'm small, but I'm all the rage

Oh-oh-oh-oh

[Verse 2]

No designer did this gown

I grew it up and wore it down

Same stuff as your manicure

Call it keratin couture

More tongue than body, packed up tight

It unrolls on the mound tonight

No teeth in this smile of mine

I grind my meals on stones I find

[Chorus]

Sequin Ball

Oh-oh-oh-oh

When I roll up, I'm having a ball

Oh-oh-oh-oh

Plate on plate, I grew it alone

Oh-oh-oh-oh

Every sequin's home-grown

Oh-oh-oh-oh

Every night I take the stage

Oh-oh-oh-oh

I'm small, but I'm all the rage

Oh-oh-oh-oh

[Bridge]

When the night plays rough, I fold

One little trick that never gets old

Snout and belly tucked inside

Even lions swallow their pride

I'm the most-wanted gown in town

I was born in this gown

One shake, one waddle, watch me roll

Back on two legs, in control

[Chorus]

Sequin Ball

Oh-oh-oh-oh

When I roll up, I'm having a ball

Oh-oh-oh-oh

Plate on plate, I grew it alone

Oh-oh-oh-oh

Every sequin's home-grown

Oh-oh-oh-oh

Every night I take the stage

Oh-oh-oh-oh

I'm small, but I'm all the rage

Oh-oh-oh-oh

[Outro]

Sequin Ball

Oh-oh-oh-oh

Sequin Ball

Oh-oh-oh-oh

Se-quin Ball, Se-quin Ball

Se-quin Ball, Se-quin Ball

Oh-oh-oh-oh

=== LYRICS AS SUNG ===

UNVERIFIED (2026-10-27). The automated lyric-completeness check

(Pipeline\check_lyric_coverage.py, SenseVoice ASR) proved unreliable on this

material - heavily garbled transcripts on all three finalist takes and one

empty transcript for a 4:31 vocal track - so what the engine actually sang

could not be machine-verified. The user listened to the selected take (final

B) and did not note a deviation. The written lyrics above remain the text of

record; verify by ear before any future re-release.

=== SETTINGS ===

Engine: yue2 / yue2 / audio.cpp v0.9.2

Weights: YuE2-3B Q8_0 GGUF + f32 VAE

Seed: 540953209 (final B - chosen at Gate 3) Planning: full Max tokens: 10000 Guidance: 1.0

VAE: f32 AR LoRA: none NAR LoRA: yue2_1980s_eurodisco_unfused u/1.0

ABC temp: 0.9 Semantic temp: 1.25 NAR steps: 12

Key: D natural minor BPM: 126 (plan Q:1/4=126) Era: 1980s Mastering recipe: yue2-light

Generated: 2026-10-27 Duration: 4:31 (270.6 s) Truncated: no

=== LORA ===

yue2_1980s_eurodisco - YuE2 NAR (texture/timbre) adapter supplying 1980s

Eurodisco production character. Trigger word "eurodisco", placed FIRST in the

style prompt. Scale 1.0. Loaded in the engine-unfused layout (yue2.nar_lora);

the ComfyUI fused layout is the same weights in another arrangement.

Download (CC0 1.0, both weight formats, model card + training workflow):

https://huggingface.co/jamespetts/yue2-1980s-eurodisco-lora

=== MASTERING ===

Recipe yue2-light, era stamp 1980s: mono below 120 Hz (compensated), top

limited 17 kHz, high-pass 28 Hz, +2 dB presence at 3 kHz, gain -1.23 dB

(peak-anchored, era loudness ceiling -13 LUFS). -12.83 LUFS in -> -14.65 LUFS

out, LRA 3.70, true peak 0.06 -> 0.10 dBTP. Gain and shelf repair not needed.

Analysis report: Source\Sequin Ball\mastering-report.txt.

Deliverable: Sequin Ball.mp3 (48 kHz 320k) with the cover embedded as APIC.

=== PROVENANCE ===

Lyrics: lyricist (GLM-5.3, Fireworks) - take 2, revised (6 named notes),

audited PASS by the main agent and approved by the user at Gate 1.

Style prompt: adapted from the validated Eurodisco form (KB/genres/eurodisco.md

s3), approved by the user at Gate 2. Key D natural minor, 126 BPM.

Genre ruling: Eurodisco = the German school; Italo-disco is a separate genre

and is excluded.

Generation: flat best-of-10 plan sweep (stop_after=abc) -> 3 finalist takes

rendered at the recorded config -> user picked final B (seed 540953209) at

Gate 3. All three takes kept in Source\Sequin Ball\.

Art: FLUX.2 [klein] via local ComfyUI, seed 20261027, 1024x1024 gouache cover;

audited (image-auditor-alt) MINOR-ISSUES with no text found; accepted by the

user at Gate 5. Cover art placement (house rule): the standalone <Song>.png

lives in the LOCAL library folder for the user's manual Souna uploads - it is

NOT uploaded to the Internet Archive (the mp3 carries the embedded art).

=== STATUS ===

Published to the Internet Archive folder "ai-eurodisco" (CC0 1.0) on

2026-10-27 as Sequin Ball.mp3 + Sequin Ball.json + Sequin Ball.abc.

I've been working on an open-source ComfyUI extension called Conditioning Layers and wanted to share it here.

The idea is to give you more control over where different prompts influence an image, especially with irregular shapes and overlapping regions.

It uses editable grayscale Influence Fields, which you can paint or generate procedurally. You can assign exclusive regions (FIXED), blend multiple prompts with normalized weights (BLENDED), and inspect their effective contributions before sampling.

The examples show a castle transitioning into an underwater reef and a single tree with four seasons following curved influence fields. Both were generated locally using Krea 2 Turbo.

GitHub: https://github.com/SurrealByDesign/conditioning-layers

Workflows: https://github.com/SurrealByDesign/conditioning-layers/tree/main/examples

The tested setup is ComfyUI 0.34.6 with Krea 2 Turbo BF16, 1024×1024, 8 steps, CFG 1, Euler/simple. The extension is free under Apache-2.0 and still experimental.

The fields guide conditioning during generation, not the finished pixels, so boundaries aren't guaranteed to be exact.

I'd appreciate any feedback, especially from people already experimenting with regional prompting in ComfyUI.

yep its free noend455.github.io/porject1 go crazy guys (and its local!)

I recently discovered a highly suspicious GitHub repository while searching for AI tools. After inspecting its source code and commit history, I found several serious red flags:

• Fake development activity: Automated workflows generating meaningless commits.
• Misleading claims: Dozens of advertised features, but almost no actual application code.
• Hidden redirects: Base64-encoded HTML pointing to an unrelated download website.
• Security bypass instructions: Encouraging users to ignore SmartScreen warnings and whitelist files in their antivirus.
• Suspicious connections: Multiple unrelated repositories directing users to the same external download domain.

I couldn't verify whether the actual executable contained malware, but these findings strongly suggest a deceptive download operation.

I've reported the repository to GitHub. I encourage everyone to report similarly suspicious repositories, too, with supporting evidence.

I'm deliberately not sharing its name or URL to avoid giving it additional exposure.

This also applies to ComfyUI custom nodes, extensions, AI utilities, and other GitHub projects. Installing a custom node can execute Python code with access to your system, files, and potentially sensitive information.

Useful tools for checking suspicious projects

• VirusTotal — Check file hashes, downloads, domains, and URLs.
• urlscan.io — Investigate suspicious websites and redirects.
• ChatGPT — Ask it to review repository source code, commit history, workflows, and potential security risks.
• GitHub Reporting — Report suspicious repositories with evidence.

No scanner or AI review can guarantee that software is safe. Avoid uploading private files to public scanning services.

I've attached a simple infographic to help others recognize these warning signs.

GitHub stars, impressive READMEs, and frequent commits are not proof of trustworthiness.

Stay safe, and please help keep the open-source community clean. ❤️

I posted this on the ComfyUI subreddit and it got some traction and was pinned on the subreddit to hopefully get some attention from the Comfy devs, so I'm reposting it here aswell

GitHub Repo: https://github.com/safzanpirani/comfyui-zip-ties

Some people wanted it MERGED into the official ComfyUI frontend, so I've opened a PR there too: https://github.com/Comfy-Org/ComfyUI_frontend/pull/21965

Feel free to open issues and PRs, but it's in a pretty stable state right now but it is quite literally zipties and nothing else, so temper your expectations.

Original post: https://www.reddit.com/r/StableDiffusion/s/DQlE9pFWpA

I've added a few things to my ComfyUI text generator since my original post.

What’s new:

• Context memory: keep refining a prompt across runs without repeating everything. Includes a usage meter and a button to start fresh. Context window size by default is 8192 tokens, you can customize the value.
• Added prompt guides for Moss Image and Fibo 2.
• VGL structured JSON prompts (recommended for Fibo 2).
• Cleaner UI with separate settings and generator nodes.
• Searchable model lists by provider (api key is required).
• Expandable settings node.

GitHub: https://github.com/ninjaGurung/ComfyUI-GOATd-Universal-Text-Generator

Let me know how it works for you, or if there’s something you’d like me to add!