ℹ️ Flash Attn V100 Status

This one doesn't sample, doesn't patch, doesn't touch your model. It just tells you the truth: is Flash Attention actually running on your GPU right now, or did it quietly fall back to something slower? Given how finicky this whole stack is to install, that's worth more than it sounds.

Why this exists

FlashAttention-2 - the version most people mean when they say "flash attention" - requires Compute Capability 8.0 or higher, which is Ampere and newer (RTX 30-series and up). If you're running a Tesla V100 (sm_70) or T4 (sm_75), you're locked out, full stop, no flag fixes it. This pack works around that by building FlashAttention-1 against the ai-bond/flash-attention-v100 fork and monkey-patching ComfyUI's attention function to use it when it can. The catch with any monkey-patch is you can't always tell from the UI whether it took. FlashAttnV100Status is the readout: drop it anywhere in your graph and it reports what the pack detected and whether it's active.

This matters more than usual here because the underlying kernel is compiled from source on your machine, by a small side-fork of a fast-moving project. Compiled extensions are exactly the kind of thing that silently stop working after a PyTorch or CUDA upgrade - the import doesn't necessarily crash, it just quietly falls back to standard attention and your renders get slower without an error telling you why. This node is your way of catching that instead of guessing.

What it does - no inputs, one output

FlashAttnV100Status takes nothing in. It has a single STRING output that reports the detected state - per the pack's own example, something like "ACTIVE sm_70" when the V100 kernel is live, or a message reflecting standard attention when it isn't. Wire that string into a Show Text node (or anything that displays a STRING) so you can actually read it; on its own the node produces a value, not a visible readout.

Since it takes no inputs, placement in the graph doesn't matter for correctness - it's a probe, not a link in the pipeline. Most people drop it near the top of the graph next to their checkpoint loader so it's easy to glance at every run, or add it once while debugging and delete it once they've confirmed things are working.

How it fits with the Controller node

This pack ships two nodes and they're meant to be used together: FlashAttnV100Controller sits between your model loader and your sampler and actually does the patching (it has its own status output too, for exactly this reason). Status is the standalone version of that same readout, useful when you want a permanent check in the corner of your workflow rather than reading it off the controller node's output every time. If you've only got the controller wired in and you're seeing normal speeds, add this node before you start troubleshooting the compile - it'll tell you in one glance whether the kernel is even active on this run.

Installing it

Same install as the rest of the pack, and it's the compile step that actually matters, not this node:

cd ComfyUI/custom_nodes
git clone https://github.com/FearL0rd/ComfyUI-Flash-Attention_v100.git

then the real work - building the V100-compatible FlashAttention fork:

pip install packaging ninja
git clone https://github.com/ai-bond/flash-attention-v100.git /tmp/flash-attn-v100
cd /tmp/flash-attn-v100
python setup.py install

Budget 20–30 minutes and 15GB+ of free RAM for that build - it's compiling CUDA kernels from source, not pulling a wheel. Restart ComfyUI afterward; the console should print 🔍 [FlashAttnV100] Checking GPU compatibility... on boot, which is the pack's own way of confirming it loaded at all before you even get to this node.

Reading the result

If the string comes back showing an active state with your GPU's compute capability (sm_70 for V100, sm_75 for T4), you're good - the kernel compiled and is patched in. If it reports standard/fallback attention instead, the most common reasons are the compile step never finishing successfully, or a CUDA Toolkit version that doesn't match the one your PyTorch build was compiled against - the README calls this out explicitly as a prerequisite, and it's the single most common way source-built CUDA extensions fail silently. Check that match before re-running the 30-minute build.

One thing worth knowing going in: if you're on a modern card - anything sm_80 and up - this whole pack has nothing to do for you. It only activates below the FlashAttention-2 cutoff by design, so don't install it expecting a speedup on an RTX 30/40/50-series GPU; you already have the real thing built into ComfyUI. This is strictly for people keeping a V100 or T4 alive.