Film Gate Pack

Clean AI video reads as AI. It's too perfect - no grain, no flutter, no dirt. The cheapest, most established fix in the post-processing playbook is a light film treatment, and MKRFilmGatePack bundles the classic projector-look effects into one node: exposure flicker, dust specks, vertical scratches, and gate weave (that tiny sideways jitter of the film in the projector gate). Feed it a clip, get back a "shot on film" version.

If you've read the pack's philosophy, this is the whole pitch in one node: practical finishing in ComfyUI instead of a separate app. It's deterministic, it's fast, and it's the kind of thing that makes generated footage read as captured - the film-grain-as-anti-detection idea that's all over community discussion about why AI video looks fake.

The four effects

Each effect has its own dial, and they're all normalized to sensible ranges:

• flicker_strength (0–0.5, default 0.08) - random exposure variation per frame. The 0.08 default is subtle; you feel it rather than see it. Crank toward 0.3+ and you get visibly throbbing, underexposed frames - use sparingly.
• dust_amount (0–0.4, default 0.02) - white and dark specks, 1–2px, scattered per frame. Dirt, basically. The default is "a few flecks"; high values start to look like a damaged print.
• scratch_amount (0–0.2, default 0.01) - vertical bright streaks, 1–2px wide, blended over columns. Real projector scratches are vertical because the film moves that way.
• gate_weave_px (0–20, default 2) - per-frame x/y shift following a slow sine-ish drift. This is the one that sells "projected," because real gates wobble a few pixels. 2px is tasteful; 20px is a horror-movie homage.

seed makes it reproducible (default 1234), and it reseeds both the random and numpy RNGs, so the same seed + same settings = the same specks and weave every run. Useful when you want a consistent look across a whole project.

How it works

Straightforward per-frame pipeline: decode the video to frames, then for each frame roll the array by the weave offsets, multiply by the flicker factor, punch in dust specks, blend in scratches, clip, and re-encode. It's all numpy and Pillow - no model involved, so it runs in seconds even on long clips. The main cost is the decode/encode, not the effect.

Outputs are the standard MKRShift video triple: video (MKR_VIDEO payload), output_path, and summary (JSON string with the applied settings and warnings). output_format defaults to auto (it matches the source's container), with gif/webp/mp4/mov/webm as options - and the usual rule applies: mp4/mov/webm need ffmpeg on the machine or the node falls back to gif with a warning. fallback_fps, filename_prefix, subfolder, overwrite, filename_label round out the controls.

Installing

It ships in MKRShift Nodes, so the standard route:

cd ComfyUI/custom_nodes
git clone https://github.com/criskb/MKRShift_Nodes

Restart ComfyUI, or use ComfyUI Manager (search "MKRShift_Nodes"). No extra Python dependencies.

The honest take

This is a fun node but it's a one-trick film-look kit, not a replacement for a proper grain-and-damage stack. If film look is your actual craft, you'll get more mileage from a dedicated grain pass plus a gate-weave node where you control the motion curve - the fixed sine drift here is pleasant but limited. Where it shines is exactly the scenario the pack is aimed at: you generated a clip, you want it to stop looking generated, and you want it in one node. Set flicker ~0.05, dust ~0.01, weave 2, and it's a genuinely good "print out of the projector" base that survives being cut with the rest of the pack's finishing tools.