Load CorridorKey Model

Despite the name, "Load CorridorKey Model" has nothing to do with API keys or license tokens. CorridorKey is the neural green screen keyer that Niko Pueringer and the Corridor Crew released - the one that separates a subject from green/blue screen footage by predicting the true foreground color for every pixel instead of just cutting a matte. This node is the front door: it finds or downloads the ~300MB GreenFormer checkpoint, loads the inference engine onto your GPU, and hands you a ck_model handle that feeds the rest of the pack.

It's the only node in the pack with no required inputs. You drop it on the canvas, leave it alone, and wire the ck_model output into CorridorKey Greenscreen. That's the whole job.

What happens on first run

The first time you execute it, three things happen in sequence, and all three take a minute:

1. If the CorridorKeyModule engine isn't installed, the node pip-installs it straight from the author's GitHub (corridorkey @ git+...), with --no-deps so it reuses your existing ComfyUI torch instead of forcing its own pinned build. The wrapper's own requirements.txt is just huggingface-hub.
2. It looks for a checkpoint in ComfyUI/models/corridorkey/ (the folder is created automatically). If there's no .pth there, it downloads CorridorKey_v1.0.pth from HuggingFace - about 300MB - and saves it as CorridorKey.pth.
3. It builds the engine at a 2048px working resolution and moves it to your GPU.

After that, runs are fast and cached. If you've already used the standalone CorridorKey app, you can drop its checkpoint into models/corridorkey/ and skip the download entirely.

The three optional toggles, explained

You can honestly ignore all of these for a first pass - auto, true, true is the right starting point. But they're your levers when something's off:

• precision (auto / fp16 / fp32): this selects the weight dtype. The engine stores weights as fp32 by default and auto keeps that; fp16 loads the weights in half precision if you want to squeeze VRAM. The wrapper's own code notes that bfloat16 breaks the numpy conversion downstream, so don't force a path that hands it bfloat16 tensors.
• use_refiner: the CNN refiner is what cleans up edge detail after the base model. On by default. If you're short on VRAM or frames are taking forever, this is the first thing to disable.
• mixed_precision: fp16 autocast during inference, on by default. Keep it on unless you're chasing a precision artifact.

The honest VRAM talk

CorridorKey was built on a 96GB RTX Pro 6000. Early builds of the standalone app reportedly wanted north of 20GB, and the author plus a few community wrappers have been optimizing since; the upstream project now claims 6–8GB on consumer cards, with a CPU fallback on Windows if your drivers predate CUDA 12.8. In ComfyUI, your two real levers are use_refiner here and refiner_scale on the Greenscreen node - kill the refiner and the model gets a lot lighter. If you're on 8GB, expect to make that trade.

Installing the pack

Via ComfyUI Manager, search ComfyUI-CorridorKey. Or manually:

cd ComfyUI/custom_nodes
git clone https://github.com/pixelworldai/ComfyUI-CorridorKeyWrapper
cd ComfyUI-CorridorKeyWrapper
pip install -r requirements.txt

Then restart ComfyUI and let the checkpoint auto-download on first use.

Troubleshooting

• First run hangs on "installing": that's the pip step pulling the engine from GitHub. Give it a few minutes; it's not stuck, it's compiling.
• Model won't download: if HuggingFace is blocked or flaky, put the checkpoint in ComfyUI/models/corridorkey/ yourself and the node will find it before it tries the network.
• Way slower than expected: check whether the engine fell back to CPU - Windows with pre-CUDA-12.8 drivers is the classic cause.

One license note before you build a product on this: CorridorKey is CC BY-NC-SA 4.0 with additional terms. You can process your own commercial images, but you can't repackage the tool or offer it as a paid inference API. Worth reading before you commit.