AetherScale • MFG

You generated a clip, you like the motion, and now you want it at 4x the frame rate. The default move in this ecosystem is RIFE - almost every long-video workflow you'll find ends ... → Rife VFI → Video Combine - and RIFE is genuinely good at it. AetherScale • MFG is the other road: it hands your frames to NVIDIA's DLSS Frame Generation, the same hardware feature games use to fake frames between real ones, and gives you back a longer IMAGE batch.

Different mechanism, different artifacts - don't assume it's strictly better.

One warning up front: this pack has essentially zero community footprint, no threads to sanity-check the author's claims against, and AetherScale's DLSS paths are labelled experimental by the author.

How it actually works

The class is still called AetherScaleMFGLab for workflow compatibility, but the default mode = native_dlssg doesn't do anything in Python. It spawns dlssg-worker.exe, a pinned binary pulled from the Konohamaru04/ComfyUI-NVIDIA-DLSS-Frame-Interpolation project, which drives nvngx_dlssg.dll over D3D12. Both files are SHA-256 verified before they run and land in ComfyUI-AetherScale/runtime/dlssg_native/.

The guide frames are yours: AetherScale grayscales the current frame, analyses it at roughly 640px width with OpenCV's DIS optical flow against the previous frame, and hands the worker a full-resolution FP16 motion field. That field is the thing DLSSG usually expects from a game engine's depth and motion buffers, so here it's estimated from pixels. That's the whole reason this is a lab node.

If your multiplier is supported natively the worker generates it in one history pass; if not, AetherScale chains 2x stages and picks frames on your requested timeline.

The inputs worth touching

multiplier - 2x through 6x, default 4x, and the README suggests 4x as the first test on RTX 50 hardware. Remember the timeline maths: a 24 fps source at 4x lands frames on a 96 fps grid. Play that back at 96 fps and the duration is unchanged; play the generated frames at 24 fps and you've made true 4x slow motion.

mode - native_dlssg is the real thing, surrogate_mv is the old pure-software fallback (motion-vector blend, linear blend, frame repeat), and probe_only is the sleeper: it queries the runtime for supported multipliers and returns your images untouched with capability stats. Run it once before kicking off a 6x overnight export.

motion_source - internal_dis (default) uses that internal optical flow. connected_motion expects the AETHERSCALE_MOTION packet from AetherScale • Motion Analysis; rgb_only ignores any motion input you've wired.

source_frame_rate - feed it the real source FPS. The frame pacing and the stats both key off it.

native_guide_source and native_scene_cut_threshold (0.24) - leave them unless you see smearing across cuts.

Ignore the legacy knobs: artifact_guard, emissive_protection, thin_detail_protection, mv_confidence_threshold, fallback_mode and synthesis_mode only apply to surrogate_mv - native mode echoes them back in stats under legacy_surrogate_controls_ignored. If the output is ugly, they will not save you.

For long clips, output_precision, output_storage and clean_cache control where the multiplied batch lives - auto plus clean_cache = true is the right starting point, and AETHERSCALE_CACHE_DIR moves the backing file to another drive.

Outputs

image is the multiplied IMAGE batch. Wire it into AetherScale • Video Combine with frame_rate set to source × multiplier, or into a frame-saving node for A/B inspection. stats is a JSON string - multiplier resolution, bootstrap details, environment - and it's what you'd attach to a bug report.

If the destination is a file rather than another ComfyUI node, stop here and use AetherScale • MFG Video instead; a 2x/4x materialised batch at multi-megapixel resolution runs into tens of gigabytes.

Installing it

Manager search for AetherScale, or:

cd ComfyUI/custom_nodes
git clone https://github.com/vizart-vj/ComfyUI-AetherScale.git

Restart ComfyUI. There's nothing to pip install - requirements.txt is deliberately empty, and NVIDIA's nvidia-vfx wheel is bootstrapped into the pack's own vendor directory on first use. That dodges the install failure people hit with the official NVIDIA RTX nodes, where the wheel won't build and you end up doing this by hand:

python_embeded\python.exe -m pip install -U --no-build-isolation nvidia-vfx --index-url https://pypi.nvidia.com

First native run needs internet: it downloads and hash-verifies the worker and DLL once, then works offline.

Where it bites

Windows 10/11 and an NVIDIA RTX card, full stop. RTX 50-series is the primary target for the stock native runtime - on older cards compatibility depends on which runtime path you can get, and you may end up on surrogate_mv, the old algorithm wearing the same widgets. If the worker can't bootstrap, check stats; a failing probe_only is your fastest diagnostic.

Keep your source clips short, compare against a RIFE pass, and let your eyes make the call.