ComfyUI v0.35.0 was tagged on 9 September 2026 at 19:55 UTC, and 92 commits separate it from v0.34.6. The release notes read like the usual partner-node round-up: WAN3-Prime, Recraft V4 Styles, Google Omni 1.1, SenseNova U1.5, GPT-6 Astra, GPT Image 2.5 Flare and Sunburst, Claude Fable 5.1, MiniMax H3 Max, Meta Muse Image, six rebuilt Tripo nodes, Pixal3D multiview.
Two things in that list are not node additions at all. One is a compilation layer that changes which models a mid-range card can finish rather than how fast it finishes them. The other is a set of nine nodes that run on Comfy's own GPUs and bill by the second, which is the first time the open-source graph has carried a running meter that is not a fixed per-generation price.
Neither is in the headline. Both change how the tool behaves on your machine. This piece takes them in turn, then covers the two changes in this release most likely to break a workflow you already saved.
Comfy Compiler and what a 32GB box can finish
The Comfy Compiler (CORE-389) is described by its author as a two-layered model compilation process: the aimdo memory compiler, shipping in comfy-aimdo 0.5.0, layered under the CUDA graphs support ComfyUI already had.
The memory compiler's job is to collapse allocation churn. It computes a minimised allocation plan so CUDA memory allocation calls happen once, then the memory footprint stays stable and constant for the rest of inference. The stated effect is twofold: it avoids CUDA async allocator thrash, and it removes VRAM under-utilisation caused by awkward allocation shapes interacting with allocator caches. The compiler uses a greedy re-allocation pass so that physical VRAM peak matches logical allocation peak, with no freed allocation left sitting in a cache.
That second property is the one that matters. If your physical peak has been running above your logical peak, you have been paying VRAM for memory you were not using, and on a card with no headroom that is the difference between a graph completing and a graph stalling.
The numbers in the merge request make the point better than the description does. On Windows with an RTX 5060 and 32GB of system RAM, running MiniMax H3 at 720p for 158 frames, the before case logs the model as staged at 19995MB and then simply stops: zero of 20 steps, and the author's note records no activity after several minutes. The after case on identical hardware reaches 2 of 20 steps in 1 minute 26 seconds, at 43.43 seconds per iteration.
That is not a speedup. It is a model that did not run becoming a model that runs slowly, which is a far more useful result for anyone generating on consumer hardware.
The autoregressive path shows the conventional kind of gain. MiniMax Music 3 generating 3 seconds of audio on the same machine goes from 8.60 iterations per second to 11.57, roughly 35% more sampling throughput, though total prompt execution only improves from 9.43 to 8.80 seconds because the sampling phase is a fraction of the total.
Coverage is partial and the release is explicit about it. Autoregressive models keep CUDA graphs; diffusion models get the memory compiler alone for now. Every model currently using the prefetcher, plus MiniMax H3, has been converted. WAN is named as future work, specifically to raise maximum generation sizes, so if WAN is your main video path this release does not yet change your ceiling.
Comfy Cloud puts a running meter in the graph
The Comfy Cloud partner nodes merged on 5 September and ship in this release as nine nodes, every one carrying a [BETA] suffix in its display name and a beta notice leading its description. They cover Z-Image Turbo, Flux 2, Mage Flow and Mage Flow Turbo for stills, four MiniMax H3 video modes including reference-to-video with up to four reference images, and MiniMax Music 3 for audio.
Mechanically they behave like any other partner node. You drop one into a local graph, it calls out to a proxy endpoint, a curated workflow runs on Comfy's GPUs, and the result comes back into your graph. The node source states plainly that this is paid in the same credits that every partner node already consumes, with no Cloud subscription required, so it is not an upsell into a separate hosted product. Worth knowing before you top up: Comfy's own documentation says top-up credits expire after a year and monthly credits expire at the end of the billing period.
The billing model is where it departs from everything around it. Every other partner node in ComfyUI quotes a fixed price for a generation. These bill by how long the GPU runs.
| Path | Runs on | Billed by | Cost known before you run |
|---|---|---|---|
| Local node | Your GPU | Nothing, beyond electricity | Yes, it is free |
| Standard partner node | Vendor API | Fixed price per generation | Yes, shown on the node badge |
| Comfy Cloud node [BETA] | Comfy Cloud GPU | GPU-second, at a published rate | No, it depends on run duration |
The rate is not a marketing number, it is a constant in the shipped source. COMFY_CLOUD_GPU_SECOND_USD is set to 0.001295, and COMFY_CLOUD_CREDITS_PER_USD to 211, which puts a GPU-second at about 0.27 credits. Multiply out and the list rate is roughly 7.8 cents per GPU-minute, or about $4.66 per GPU-hour.
The comment block around those constants is unusually candid, and worth reading if you are deciding whether to trust the badge. It records that the value is a hand-maintained mirror of the vendor rate card with nothing linking the two, that it was briefly set to 0.00185 after being read off a card entry for a different GPU class, and that the wrong value over-quoted every run by about 43% until someone divided a real billed event to get the truth.
It also explains why the number is deliberately conservative. ComfyUI is pulled rather than pushed, so a user keeps whatever value they last pulled indefinitely. Ship a promotional rate in the source and it does not expire when the promotion does: the rate card returns to list, the user's node still quotes the discount, and they get charged more than they were shown. Quoting above the charged rate is the safe direction. The source names a server-supplied per-run estimate as the only safe long-term fix, which is the honest way of saying there is no reliable pre-run cost estimate today.
For a creator the practical consequence is simple. A per-generation node lets you budget a batch by multiplying. A per-GPU-second node does not, because a prompt that takes twice as long costs twice as much, and you find out afterwards.
The two changes most likely to break a saved workflow
First, models were removed rather than deprecated in place. Google's Veo 2 and Veo 3.0 nodes were dropped because Google was retiring them upstream, and a second pass removed further retired partner models. If a saved graph references one of those nodes, it will not resolve after you update.
Second, and easier to miss, is the partner run gate. The flag partner_run_gate_enabled is now registered in the CLI feature flag registry as a boolean defaulting to true, described as gating the local Run button behind sign-in when the graph contains partner nodes. The registration matters because before it existed the flag silently did nothing: unregistered keys passed through as raw strings, and the string "false" is truthy on the frontend, so operators who thought they had turned the gate off had not.
The net effect is that a single partner node anywhere in an otherwise local graph puts your Run button behind a sign-in prompt. An operator can turn that off by launching with --feature-flag partner_run_gate_enabled=false, and only now does that flag actually work.
The rest of the release is quieter but lands in the same place. There is a substantial batch of alpha channel correctness fixes covering Invert Image, Blend Images, Quantize Image, Draw Text Overlay, Detect Edges, the colour adjustment nodes, the RGB and YUV conversion nodes, and transparent Porter-Duff blend modes. If you composite with transparency in ComfyUI, some of your prior output was subtly wrong, and this is the release where it stops being wrong.
Alongside those: VideoTrim and VideoCrop nodes, HEVC remuxing to MP4 and MOV as hvc1, AVIF saving, a Sparse Attention node, a colour space conversion node, File3DToMesh for GLB, GLTF, OBJ and STL, LTXV generated-keyframe nodes with Freeze Latent and LTXVAddLatentGuide, and a memory fix that makes ComfyUI respect a container cgroup limit instead of reading host RAM.
What to do next
Update, then check three things in this order. Open any saved graph that uses a Google video node and confirm it still resolves, because Veo 2 and Veo 3.0 are gone. If you run headless or in a container, decide now whether you want the partner run gate on, because the default is on and it will stop an unattended run at a sign-in prompt. If you generate on a card that has been stalling rather than finishing, retest that exact graph, because the compiler changes the failure case more than it changes the fast case.
Treat the Comfy Cloud nodes as what their own label says they are. They are beta, the curated set is expected to change, workflows can be retired, and the price you see is a hand-maintained figure that has been wrong before in the direction of over-quoting. Run one, check the actual credits charged against the rate, and size your batches from the real number rather than the badge.
Frequently asked questions
Does Comfy Cloud require a separate subscription?
No. The node source states the nodes are paid in credits with no Cloud subscription required. They draw on the same credit balance as any other partner node, so if you already use partner nodes you can run them without signing up for anything new.
How much do Comfy Cloud nodes actually cost?
The list rate shipped in v0.35.0 is $0.001295 per GPU-second, which is about 0.27 credits per second, roughly 7.8 cents per GPU-minute or about $4.66 per GPU-hour. Because billing follows run duration rather than output count, the total for a given prompt is not knowable before it runs.
Will Comfy Compiler make my existing generations faster?
Sometimes, but that is not its main effect. On the autoregressive path the reference test gained about 35% sampling throughput. On the diffusion path the reference test went from stalling with no output to completing steps at all. If your graphs already finish comfortably within VRAM, expect a modest change.
Does the compiler cover every model?
No. Models using the prefetcher plus MiniMax H3 have been converted. Autoregressive models continue to use CUDA graphs while diffusion models currently get the memory compiler only. WAN is listed as future work, aimed at increasing maximum generation sizes.
Which nodes were removed in this release?
Google Veo 2 and Veo 3.0 were dropped ahead of Google retiring them upstream, and a follow-up pass deprecated further retired partner models. Saved workflows referencing those nodes will not resolve after updating.
Why does my Run button now ask me to sign in?
Because the graph contains at least one partner node and partner_run_gate_enabled defaults to true. An operator can disable it by starting the server with --feature-flag partner_run_gate_enabled=false, which only became functional once the flag was registered in this release.
