EZSCAPE

CorridorKey explained: Corridor Digital's open-source AI chroma keyer

In late 2024, Niko Pueringer of Corridor Digital released CorridorKey, an open-source chroma keyer that uses a neural network to separate foreground subjects from green screen backgrounds. The approach is fundamentally different from how traditional keyers work. Instead of thresholding green pixels and hoping for the best, CorridorKey uses a technique called neural unmixing to reverse the physical process of light mixing.

The result: cleaner edges on hair, preserved motion blur, and transparent or translucent elements that survive the key instead of getting destroyed by it.

CorridorKey is open source. That means anyone can read the code, modify it, and build on top of it. And people have. A growing ecosystem of forks and plugins has appeared since the original release, making the technology accessible to editors who would never touch a Python script or command line.

This guide covers what CorridorKey is, how the underlying technology works, the community forks that have emerged, and how EZ-CorridorKey fits into that picture.

What is CorridorKey?

CorridorKey is an AI-powered chroma keyer created by Niko Pueringer of Corridor Digital. It was released as an open-source Python project on GitHub.

Traditional chroma keyers look at each pixel and ask: "Is this green enough to remove?" They use color math, edge softening, and spill suppression to carve out a matte. This works well on clean studio footage with even lighting and simple edges. It falls apart on hair, semi-transparent fabric, smoke, motion blur, and anything where the foreground and background colors blend together at the subpixel level.

CorridorKey asks a different question. It takes a green screen plate and a rough alpha hint (a coarse mask that tells the network approximately where the subject is), then uses a trained neural network to separate the image into two outputs: the clean foreground color and a linear alpha matte.

The neural network was trained to understand how light physically mixes when a foreground object sits in front of a colored background. It learned to reverse that mixing. The technical term for this is neural unmixing, and it produces results that traditional color-based keyers cannot match on difficult footage.

CorridorKey does not replace your entire keying workflow. You still need to shoot on green screen. You still need decent lighting. But for the hardest parts of keying, the fine hair strands, the wispy edges, the see-through fabric, it handles those with a level of quality that previously required hours of manual roto work.

How does neural unmixing work?

To understand neural unmixing, start with the problem it solves.

When you photograph a person standing in front of a green screen, the camera sensor captures light that is a physical mixture of two sources: light bouncing off the person (foreground) and light bouncing off the green background. At the edges, especially around hair and semi-transparent materials, these two light sources blend together. A single pixel might be 60% foreground and 40% green screen.

Traditional keyers try to classify each pixel as "foreground" or "background" based on its color. They use thresholds. If a pixel is greener than X, call it background. If it is less green than Y, call it foreground. Everything in between gets a partial alpha value based on how green it is. This is fast and works well enough for hard edges. But it is fundamentally limited because it is making a binary decision based on color alone.

Neural unmixing treats the problem as a physics equation. The pixel color you see (C) is a blend of the true foreground color (F) and the background color (B), weighted by the alpha value (a):

C = a * F + (1 - a) * B

Given C (what the camera recorded) and B (the known green screen color), the neural network solves for both F and a simultaneously. It does not threshold. It does not guess. It produces both the clean foreground color and the correct alpha value for every pixel.

The network was trained on large datasets of composited images where the ground truth foreground, background, and alpha were all known. Over millions of training examples, it learned the patterns of how different materials (hair, glass, fabric, skin) interact with colored light. The trained model generalizes to new footage it has never seen.

This is why CorridorKey preserves detail that traditional keyers throw away. It is not deciding "green or not green." It is computing the physical separation of two blended light sources.

The coarse alpha hint

CorridorKey requires a second input beyond the green screen plate: a coarse alpha hint. This is a rough mask that tells the network where the subject approximately is. It does not need to be precise. A sloppy roto shape or even a simple bounding box works.

The alpha hint is a spatial guide. Without it, the network would have to figure out where the subject is and how to unmix it. With the hint, the network can focus its compute on the unmixing problem, which improves both speed and accuracy.

Different CorridorKey forks generate this alpha hint in different ways. Some use SAM (Segment Anything Model). Some use other segmentation networks. Some let you paint the mask manually. The approach varies, but the purpose is the same: give the neural network a rough idea of the subject's location.

The original CorridorKey

The original CorridorKey release was a Python script. You ran it from the command line. It processed images frame by frame and output the separated foreground and alpha as image sequences.

The results were impressive. But the barrier to entry was high.

Hardware requirements: The original implementation needed a GPU with 24GB or more of VRAM. That limited it to NVIDIA RTX 3090, RTX 4090, and professional cards like the A5000 and A6000. Most editors do not own these cards. Even among technical users with powerful workstations, 24GB VRAM was a significant constraint.

Technical requirements: Running the original meant installing Python, setting up CUDA dependencies, downloading model weights, and executing commands in a terminal. There was no graphical interface. No preview. No integration with any editing application. You processed frames, got output files, and imported them manually.

Workflow friction: Processing was slow relative to real-time. A 10-second shot at 24fps meant processing 240 individual frames, each taking several seconds. The output was an image sequence that then needed to be composited in your NLE. No batch automation. No queue system.

For VFX professionals and technical hobbyists, this was fine. They were comfortable with Python and had the hardware. For the average editor who wanted better green screen results, the original CorridorKey was effectively inaccessible.

The fork ecosystem

Because CorridorKey is open source, anyone can fork the code and build on it. And people have. A healthy ecosystem of community forks has appeared since the original release, each solving different parts of the accessibility problem.

OFX plugins for DaVinci Resolve and Nuke

Several developers have wrapped CorridorKey's neural unmixing into OFX plugins. OFX (Open Effects) is a plugin standard supported by DaVinci Resolve, Nuke, Natron, and other compositing tools. These plugins let you apply CorridorKey directly to clips in your timeline or node graph, eliminating the image sequence round-trip.

After Effects and Premiere Pro plugins

Baskl.ai and Blace.ai have both created implementations that bring CorridorKey-style neural unmixing into Adobe's ecosystem. These vary in how closely they follow the original model architecture and how they handle the alpha hint generation.

Standalone GUI tools

Other forks have built desktop applications around the core technology, adding graphical interfaces, preview windows, and processing queues. These make the tool accessible to users who are not comfortable with command-line workflows.

EZ-CorridorKey by EZSCAPE

EZ-CorridorKey is EZSCAPE's fork of the original CorridorKey. It has over 4,000 stars on GitHub, making it the #1 fork. It is a desktop GUI application that wraps the neural unmixing pipeline with:

  • ☼ A visual interface for loading footage and previewing results
  • ☼ Support for both green screen and blue screen keying (added in v2.0)
  • ☼ Batch processing for handling multiple shots in sequence
  • ☼ Multiple alpha hint generators (BiRefNet, GVM, VideoMaMa, MatAnyone2, Apple Vision MLX, and manual chroma key)
  • ☼ VRAM optimizations that reduce the GPU memory requirement from the original 24GB

EZ-CorridorKey is source-available and a work in progress. It is not a finished, polished product. Features are still being added, bugs are still being fixed, and the interface is still evolving. EZSCAPE maintains it as one of several tools in their plugin ecosystem.

It is worth being direct about this: EZ-CorridorKey is one fork among many. It happens to be the most-forked and most-starred version on GitHub, but that does not make it the "official" or "best" implementation. Different forks make different tradeoffs. Some optimize for speed. Some optimize for quality. Some target specific NLEs. The right fork for you depends on your hardware, your NLE, and your workflow.

Hardware requirements

The original CorridorKey needed 24GB of VRAM. Community forks have pushed that number down significantly through various optimization techniques.

GPU memory (VRAM)

  • ☼ Original CorridorKey: 24GB+ VRAM required (RTX 3090, RTX 4090, A5000/A6000)
  • ☼ Optimized forks: Most now work on 8GB+ VRAM GPUs (RTX 3060 12GB, RTX 4060 Ti, etc.)
  • ☼ Minimum practical: 8GB VRAM. Below this, processing either fails or requires aggressive tiling that impacts quality
  • ☼ Recommended: 12GB+ VRAM for comfortable processing of HD footage without tiling artifacts

GPU vendor support

  • ☼ NVIDIA (CUDA): Best supported. All forks work with NVIDIA GPUs. CUDA is the primary compute backend for the neural network
  • ☼ Apple Silicon (MLX): Some implementations have added MLX support, which runs the model on Apple's unified memory architecture. Performance varies. The M1 Pro/Max/Ultra and M2/M3/M4 chips have enough unified memory to handle the model
  • ☼ AMD (ROCm): Limited support. Some forks work on AMD GPUs via ROCm on Linux. Windows AMD support is spotty

CPU fallback

Some forks allow CPU-only processing. It works, but it is slow. A frame that takes 2-3 seconds on a GPU might take 30-60 seconds on a CPU. For testing or occasional use, CPU mode is functional. For production work with hundreds of frames, you need a GPU.

Resolution considerations

Higher resolution footage requires more VRAM. Processing 4K frames takes roughly 4x the memory of 1080p frames. If your GPU has 8GB of VRAM, you may need to process 4K footage in tiles (splitting each frame into overlapping sections, processing them separately, and stitching the results). Most optimized forks handle tiling automatically, but the overlap regions can sometimes show subtle artifacts.

CorridorKey vs traditional keyers

Traditional keyers and CorridorKey solve the same problem with completely different approaches. Neither is universally better. Each has strengths and weaknesses.

Traditional keyers

Tools like Keylight (After Effects), Delta Keyer (Fusion/Resolve), Primatte, and Ultimatte have been the industry standard for decades. They work by analyzing pixel colors and separating foreground from background based on chroma relationships.

Strengths of traditional keyers:

  • ☼ Real-time or near-real-time processing. You see results instantly as you adjust parameters
  • ☼ Fine-grained manual control over every aspect of the key: clip black, clip white, screen gain, spill suppression, edge softness
  • ☼ Decades of refinement. These tools are mature, stable, and well-documented
  • ☼ No special hardware requirements beyond what your NLE already needs
  • ☼ Non-destructive. Adjust parameters at any point without reprocessing

Weaknesses of traditional keyers:

  • ☼ Hair and fine detail. Thin strands of hair that blend with the green screen are extremely difficult to key cleanly. You either lose detail or retain green fringing
  • ☼ Motion blur. When a subject moves quickly, the motion-blurred edges contain a mixture of foreground and background that color-based keyers struggle to separate
  • ☼ Semi-transparent materials. Glass, sheer fabric, smoke, and fog all pass background color through them. Traditional keyers often destroy or distort these elements
  • ☼ Uneven lighting. If the green screen has hot spots, shadows, or wrinkles, the color variation makes clean keying much harder. You end up pulling multiple keys and combining them

CorridorKey's neural approach

Strengths:

  • ☼ Hair and fine detail. The neural network excels at separating individual hair strands from the background without the fringing that plagues traditional keyers
  • ☼ Motion blur. Because the network understands physical light mixing, it handles blurred edges more accurately
  • ☼ Semi-transparent elements. Translucent materials are preserved with their correct opacity, not flattened or removed
  • ☼ Spill handling. The neural unmixing process inherently separates green spill from the foreground color, often producing cleaner results than manual spill suppression

Weaknesses:

  • ☼ Processing speed. CorridorKey is not real-time. Each frame takes seconds to process. For a 30-second shot at 24fps, you are waiting minutes, not seconds
  • ☼ Batch workflow. You process your footage, wait, then use the result. This is fundamentally different from the interactive adjust-and-preview loop that traditional keyers offer
  • ☼ Hardware cost. You need a capable GPU. Traditional keyers run on almost anything
  • ☼ Less manual control. The neural network makes decisions that you cannot directly override. If it gets something wrong, your options for correction are limited compared to the dozens of knobs on a traditional keyer
  • ☼ Maturity. CorridorKey has existed for about two years. Traditional keyers have had decades of development, edge case handling, and production testing

When to use which

Use a traditional keyer when:

  • ☼ Your green screen is well-lit and even
  • ☼ The subject has hard, clean edges (no wispy hair or transparent materials)
  • ☼ You need real-time feedback while adjusting
  • ☼ Your GPU does not meet CorridorKey's requirements
  • ☼ You are doing live production or broadcast work where latency matters

Use CorridorKey when:

  • ☼ The shot has difficult hair, fur, or fine detail against the green screen
  • ☼ There is motion blur on the edges
  • ☼ The subject includes transparent or semi-transparent elements
  • ☼ The green screen has uneven lighting that makes traditional keying painful
  • ☼ You can afford the processing time and have a capable GPU

Use both when:

  • ☼ You need a quick key for rough editing (traditional) and a final quality key for finishing (CorridorKey)
  • ☼ Different shots in your project have different keying challenges

Many editors are finding that the best workflow combines both approaches. Use your traditional keyer for the easy shots and reach for CorridorKey when a shot is giving you trouble.

Getting started with CorridorKey

If you want to try CorridorKey, you have several options depending on your technical comfort level and your NLE.

Option 1: A community fork with a GUI

The easiest entry point. Download a fork that includes a graphical interface, point it at your green screen footage, and process. EZ-CorridorKey is one such option. Others exist. Search GitHub for "CorridorKey" and sort by recently updated to see what is active.

Option 2: An NLE plugin

If you work in DaVinci Resolve, Nuke, After Effects, or Premiere Pro, look for a CorridorKey plugin that supports your application. OFX plugins work in Resolve and Nuke. AE/Premiere plugins from Baskl.ai and Blace.ai target Adobe's ecosystem.

Option 3: The original Python script

If you are comfortable with Python, CUDA, and command-line tools, the original repository is still available on GitHub. This gives you the most control but requires the most technical setup. Follow the README instructions, install dependencies, download model weights, and run the processing script.

Tips for good results

Regardless of which fork or plugin you use:

  • ☼ Light your green screen evenly. CorridorKey is more forgiving than traditional keyers on uneven screens, but even lighting still produces better results
  • ☼ Shoot at the highest quality your camera supports. More color information gives the neural network more to work with. Avoid heavy compression if you can
  • ☼ Use the alpha hint. Do not skip this step. Even a rough mask significantly improves output quality
  • ☼ Process a few test frames first. Before batch processing an entire shot, run 3-5 frames to check quality and catch any issues early
  • ☼ Compare against your traditional keyer. On some shots, your existing keyer might actually produce better results. CorridorKey is not magic. It is a tool with specific strengths

FAQ

Is CorridorKey free?

Yes. The original CorridorKey by Corridor Digital is open-source software released on GitHub at no cost. Most community forks, including EZ-CorridorKey (4,000+ stars on GitHub, also available on Gumroad), are also free. Some commercial implementations based on the same neural unmixing research may charge for their products, but the core CorridorKey code and model weights are available for anyone to download and use.

Does CorridorKey work in DaVinci Resolve?

Not directly from the original release. The original CorridorKey is a standalone Python script. However, community developers have built OFX plugin versions that run inside DaVinci Resolve's Fusion page and Edit page. EZ-CorridorKey is a standalone GUI application that you use alongside Resolve. You process your green screen footage in EZ-CorridorKey, then import the keyed result into your Resolve timeline.

What GPU do I need for CorridorKey?

The original release required 24GB+ of VRAM, limiting it to high-end GPUs like the NVIDIA RTX 3090 or RTX 4090. Optimized community forks have reduced this to 8GB+ of VRAM. An NVIDIA GPU with 12GB of VRAM (such as the RTX 3060 12GB or RTX 4070) provides a comfortable experience for HD footage. Apple Silicon Macs with 16GB+ of unified memory can run some forks via MLX.

How is CorridorKey different from Runway or other AI video tools?

CorridorKey solves a specific problem: separating foreground from background on green screen footage using neural unmixing. It is not a generative AI tool. It does not create or modify content. It does not hallucinate pixels. It analyzes the physical light mixing in your actual footage and mathematically reverses it. Runway, Topaz, and similar tools use AI for broader creative tasks like background replacement, style transfer, and video generation. CorridorKey does one thing, chroma keying, and focuses entirely on doing that one thing at the highest possible quality.

Can CorridorKey replace my existing keyer?

Not entirely. CorridorKey excels at the hardest keying challenges: hair detail, motion blur, and semi-transparent materials. But it processes frames in a batch workflow, not in real time. For quick keys, rough cuts, and simple shots with clean edges, a traditional keyer like Keylight or Delta Keyer is still faster and more practical. The best approach for most editors is to keep both tools available and reach for CorridorKey when a shot is too difficult for your traditional keyer to handle cleanly.

CorridorKey and EZ-CorridorKey are developed by Ed Zisk at EZSCAPE, creator of DITHERON, CRTified, and Cucolori.