Save 4 hours! We auto-setup your workflow! Free!

Drop your workflow.json — we handle every dependency, custom node, and model. Just open the link and run.

Auto-Setup Workflow Json (Free) Now!
ComfyUI > Nodes > ComfyUI-AetherScale > AetherScale • MFG

ComfyUI Node: AetherScale • MFG

Class Name

AetherScaleMFGLab

Category
AetherScale/MFG
Author
vizart-vj (Account age: 2430days)
Extension
ComfyUI-AetherScale
Latest Updated
2026-11-08
Github Stars
0.08K

How to Install ComfyUI-AetherScale

Install this extension via the ComfyUI Manager by searching for ComfyUI-AetherScale
  • 1. Click the Manager button in the main menu
  • 2. Select Custom Nodes Manager button
  • 3. Enter ComfyUI-AetherScale in the search bar
After installation, click the Restart button to restart ComfyUI. Then, manually refresh your browser to clear the cache and access the updated list of nodes.

Visit ComfyUI Online for ready-to-use ComfyUI environment

  • Free trial available
  • 16GB VRAM to 80GB VRAM GPU machines
  • 400+ preloaded models/nodes
  • Freedom to upload custom models/nodes
  • 200+ ready-to-run workflows
  • 100% private workspace with up to 200GB storage
  • Dedicated Support

Run ComfyUI Online

AetherScale • MFG Description

Generates intermediate video frames using NVIDIA DLSS for smoother animation in ComfyUI.

AetherScale • MFG:

AetherScaleMFGLab, displayed in ComfyUI as “AetherScale • MFG,” generates additional frames for image sequences, helping you create smoother-looking animation or video from existing frames. Its primary method is native NVIDIA DLSS Frame Generation through a Direct3D 12 worker, with DIS-based motion guides that describe how visible content moves between frames. It also offers a surrogate backend for alternative processing and debugging, plus a probe mode for investigating backend readiness. Frame generation addresses temporal smoothness rather than increasing image resolution: its purpose is to add intermediate moments, not enlarge individual pictures. Motion guidance and scene-cut handling help manage moving subjects and abrupt shot changes, although results depend on the source material and the selected backend. Native processing requires a compatible runtime and hardware environment; the supplied class does not establish exact hardware requirements or guarantee automatic recovery when native processing is unavailable.

AetherScale • MFG Input Parameters:

images

Required connection of type IMAGE containing the source image sequence. These are the frames from which the backend generates its result, so use a batch arranged in chronological order rather than unrelated pictures. Motion-guided processing relies on meaningful relationships between neighboring frames; inconsistent ordering can therefore produce unsuitable motion information. The class does not declare a default, numeric range, minimum frame count, resolution restriction, or accepted pixel-precision requirements for this connection.

mode

Required selection with options native_dlssg, surrogate_mv, and probe_only; the default is native_dlssg. This selects the processing backend or diagnostic path. native_dlssg requests the native NVIDIA DLSS Frame Generation implementation described by the node, while surrogate_mv selects the alternative surrogate implementation. probe_only is a probe-oriented mode rather than the normal generation choice; the supplied class does not show which checks it performs or what image result it returns. Use native mode for the intended DLSSG workflow and surrogate mode when deliberately testing the alternative method. The class does not show an automatic switch between these modes if one fails.

multiplier

Required selection with options 2x, 3x, 4x, 5x, and 6x; the default is 4x. The node converts your selection into the corresponding integer and passes it to the generation backend as the requested frame-generation multiplier. Higher values request greater temporal expansion and generally involve more generated image data. For example, 4x requests a fourfold frame-generation factor, but the exact returned frame count depends on backend treatment of the sequence boundaries. The supplied class does not define that frame-count formula.

motion_source

Required selection with options internal_dis, connected_motion, internal_compact, and rgb_only; the default is internal_dis. This specifies the requested motion-information route for the backend. The internal choices request internally produced motion guidance, while connected_motion requests the route associated with the optional motion connection. rgb_only has an explicit effect in this class: it discards any connected motion packet before calling the backend. The exact algorithms and backend-specific handling of the other choices are not shown here. Native guide selection also has its own control, native_guide_source, so do not assume this parameter alone determines native guidance.

surrogate_method

Required selection with options mv_blend, linear_blend, and frame_repeat; the default is mv_blend. This selects the requested synthesis method for the surrogate backend. The options distinguish motion-vector-guided blending, direct blending between source pictures, and repeating source frames. Direct blending can create overlapping outlines around moving subjects, while repeating frames preserves existing pictures without adding genuinely new motion positions. Motion-guided blending attempts a more movement-aware result, but its quality depends on the motion estimate. The supplied class forwards the selection without showing the detailed implementation or establishing any effect on native DLSSG processing.

scene_cut_strategy

Required selection with options repeat_previous, repeat_current, and linear_blend; the default is repeat_previous. This requests how generated positions should be treated around detected scene changes: use the previous frame, use the current frame, or blend between them. Repeating one side can avoid the overlapping shots associated with a crossfade, while blending deliberately mixes the two images. This parameter specifies a strategy rather than a detection threshold. The supplied class does not show how each backend applies it, so native scene-cut behavior should also be evaluated with native_scene_cut_threshold.

cuda_device

Required integer selecting the CUDA device index, with default 0, minimum 0, and step 1. Its maximum is the number of CUDA devices detected by PyTorch minus one, but never below 0. On a system with two detected CUDA devices, for example, the selectable indices are 0 and 1. This value requests which CUDA device the backend should use. An available index does not by itself establish native DLSSG compatibility, and the interface still exposes 0 when CUDA is unavailable, so the presence of this control is not proof that GPU processing can run.

output_device

Required selection with options cpu_safe and same_as_input; the default is cpu_safe. This requests the device-placement policy for the returned image data. cpu_safe requests the CPU-safe output route, while same_as_input requests placement matching the incoming image tensor. This matters when planning memory use and connecting downstream processing, particularly if the input already resides on a GPU. The actual transfers and allocations are implemented by the backend and are not visible in this class. Selecting cpu_safe does not mean that native frame generation itself runs on the CPU.

motion

Optional connection of type AETHERSCALE_MOTION, with no connected default; the execution default is None. It supplies a motion-analysis packet rather than an ordinary image. AetherScale • Motion Analysis is shown in the supplied context as a node that produces such a packet, making it a relevant source when you want connected motion guidance. Use motion analysis corresponding to the same source sequence so its timing and movement information remain relevant. When motion_source is rgb_only, this class ignores the connection. Requirements for missing or incompatible packets are enforced downstream and are not shown here.

output_precision

Optional selection with options auto, float16, and float32; the default is auto. This requests the numeric precision used for output image storage. Half-precision float16 uses less raw storage per value than float32, while float32 retains greater numerical precision. auto delegates the choice to the backend; its decision rules are not supplied. This is an output-storage precision request, not evidence that every internal calculation or native worker operation uses the same precision.

output_storage

Optional selection with options auto, mmap, and ram; the default is auto. This requests how output data is stored. ram requests memory-backed storage, while mmap requests memory-mapped storage, which can let large data be accessed through a file-backed mapping instead of relying entirely on ordinary in-memory allocation. auto lets the backend choose. Storage choice becomes more important for long sequences, large frames, and high multipliers. The class does not specify automatic selection rules, backing-file locations, cleanup behavior, or available-disk-space requirements.

clean_cache

Optional Boolean with default True. This passes a cache-cleanup request to the backend. Cache management can matter during repeated runs or memory-heavy workflows, but the supplied class does not identify the caches affected, the cleanup timing, or its performance cost. Keep the default as a starting point; do not treat it as a guarantee that all GPU, system-memory, or disk-backed allocations will be released.

artifact_guard

Optional floating-point value with default 1.0, minimum 0.0, maximum 1.0, and step 0.05. This passes an artifact-guard setting to the backend as part of its synthesis controls. It is intended as an artifact-management control, but the supplied class does not define its mathematical behavior, which defects it detects, or which execution paths apply it. Start with the default and compare a short, difficult passage before changing it. Neither endpoint should be interpreted as a documented guarantee of unrestricted synthesis or artifact-free output.

emissive_protection

Optional floating-point value with default 0.85, minimum 0.0, maximum 1.0, and step 0.05. This passes an emissive-protection setting to the backend, providing a control relevant to bright or glowing content such as lights and luminous effects. The supplied class does not reveal how those areas are identified, how the setting changes their treatment, or which modes use it. If glowing details show problems, compare small adjustments on the same short sequence rather than assuming the highest setting must produce the best result.

thin_detail_protection

Optional floating-point value with default 0.75, minimum 0.0, maximum 1.0, and step 0.05. This passes a protection setting associated with fine, narrow visual details, such as wires or slender outlines. Such content can be challenging in frame interpolation because even small motion-estimation errors are noticeable. However, the supplied class does not show the detection method, strength mapping, or backend applicability. Treat it as a tuning control and judge changes using close inspection of the generated frames, not just the original frames.

mv_confidence_threshold

Optional floating-point value with default 0.45, minimum 0.0, maximum 1.0, and step 0.01. This requests a threshold associated with motion-vector confidence, meaning the backend's assessment of how trustworthy its movement guidance is. It belongs to the controls for handling uncertain motion, but the supplied class does not show the confidence calculation, comparison rule, or precise relationship to fallback behavior. Begin with the default and evaluate adjustments alongside fallback_mode when testing the surrogate path on difficult movement.

fallback_mode

Optional selection with options linear_blend and closest_source; the default is linear_blend. This selects the requested fallback image-construction method when the backend uses a fallback path. linear_blend describes mixing source images, while closest_source describes choosing a nearby source frame instead. These choices represent a trade-off between blended transitions and preserving an existing image without blended outlines. The triggering conditions and backend coverage are not shown. This parameter is not a documented mechanism for switching from unavailable native DLSSG processing to the surrogate backend.

synthesis_mode

Optional selection with options continuous_temporal and legacy_guarded; the default is continuous_temporal. This chooses between two named synthesis policies exposed by the backend. The supplied class establishes their availability but does not define their algorithms, temporal weighting, artifact handling, or applicability to each execution mode. Use the default for an initial test, and compare legacy_guarded on the same source material if you need to investigate differences. Claims that either policy is always smoother, sharper, or faster cannot be established from this class.

source_frame_rate

Optional floating-point value with default 24.0, minimum 0.01, maximum 240.0, and step 0.01. This provides the source sequence's frame rate to the backend, expressing how many original frames represent one second. Match it to the actual source timing rather than entering your desired final playback rate. The node returns images rather than an encoded video, and this class does not show automatic configuration of a downstream video writer. When assembling the result into a video, choose the final frame rate deliberately to obtain the intended duration and speed.

native_auto_bootstrap

Optional Boolean with default True. This passes an automatic-bootstrap request for the native processing path. It allows the backend to attempt its native setup procedure, but the supplied class does not show which dependencies it prepares, whether downloads occur, or what permissions and network access may be necessary. Keeping it enabled is the default starting point for native processing; it does not guarantee that an unsupported operating environment or GPU can be made compatible.

native_guide_source

Optional selection with options internal_dis, connected_motion, and zero_motion; the default is internal_dis. This selects the requested motion-guide source for the native backend. internal_dis requests internally generated DIS guidance, connected_motion requests connected motion data, and zero_motion requests guidance representing no movement. Use the connected choice when deliberately supplying a corresponding motion packet, and reserve zero-motion testing for situations where ignoring motion is intentional. Because motion_source="rgb_only" removes the packet before execution, that setting should not be combined with an expectation that native processing receives connected motion.

native_scene_cut_threshold

Optional floating-point value with default 0.24, minimum 0.01, maximum 1.0, and step 0.01. This passes a scene-cut threshold to the native backend, supporting detection of abrupt changes between shots. Correct cut detection matters because motion guidance between unrelated shots can be inappropriate. The supplied class does not expose the comparison metric or threshold direction, so it cannot establish precisely how increasing or decreasing the value changes sensitivity. Use the default first, then compare known cuts and continuous-motion passages when tuning it.

AetherScale • MFG Output Parameters:

image

Output of type IMAGE containing the image result returned by the selected backend. During frame-generation processing, this is the sequence you pass onward for image inspection, further processing, or video assembly. It is image data, not an encoded video file, so playback timing must be handled appropriately downstream. The class does not guarantee an exact frame-count formula, final device, or final precision independently of the backend and your settings. In probe_only mode, the returned image behavior is not defined by the supplied implementation.

stats

Output of type STRING containing the backend's statistics serialized as JSON with two-space indentation. It provides a readable text representation of whatever diagnostic or execution information the backend returns. Connect it to a text-display node or inspect it when comparing configurations and troubleshooting processing. The supplied class does not define the available fields, so do not assume it always includes particular timing, memory, frame-count, compatibility, or fallback entries. It is diagnostic text rather than additional image data.

AetherScale • MFG Usage Tips:

  • Start with a short, chronologically ordered sequence and multiplier="2x" before committing to a long 4x or 6x run. Check motion, shot boundaries, and memory use before increasing the workload.
  • For the intended native workflow, begin with mode="native_dlssg", native_guide_source="internal_dis", and native_auto_bootstrap=True. If processing fails, inspect the console and AetherScale • Diagnostics rather than assuming bootstrap guarantees compatibility.
  • To test externally analyzed motion, generate a corresponding packet with AetherScale • Motion Analysis and connect it to motion. Choose motion_source="connected_motion" and, when requesting native connected guidance, native_guide_source="connected_motion".
  • Avoid motion_source="rgb_only" when you expect connected motion to be used: the node explicitly replaces the connected packet with None in that configuration.
  • For surrogate comparisons, use mode="surrogate_mv" and test mv_blend, linear_blend, and frame_repeat on identical source frames. This makes it easier to distinguish motion-guidance problems from artifacts caused by simple blending.
  • Keep scene_cut_strategy="repeat_previous" as an initial surrogate setting for hard cuts, and compare repeat_current if the cut timing feels wrong. Use linear_blend only when mixing the neighboring shots is acceptable.
  • For large outputs, compare output_precision="float16" and output_storage="mmap" against your normal settings. These request lower per-value storage and memory-mapped output respectively, but actual benefits depend on backend support and your machine's memory and storage performance.
  • Enter the real source_frame_rate and separately configure your video assembly rate. For example, a 24 fps source with a requested 4x factor suggests a nominal 96 fps playback target when preserving duration, but verify the returned frame count and boundary handling.
  • Adjust artifact-related settings one at a time using a passage containing the actual problem, such as glowing edges or thin wires. Their exact implementation is not shown, so controlled visual comparisons are more reliable than assuming a higher value always improves quality.

AetherScale • MFG Common Errors and Solutions:

Native DLSSG initialization or worker failure — diagnostic category, not a quoted error

  • Explanation: Native mode depends on a D3D12 DLSSG worker and a compatible runtime environment. The supplied class contains no exact backend error strings or complete compatibility requirements.
  • Solution: Read the full console error, inspect AetherScale • Diagnostics, and verify compatibility against the installed backend's requirements. Leave native_auto_bootstrap=True if automatic setup is intended. Select mode="surrogate_mv" explicitly if you want to test the alternative backend.

CUDA unavailable or device selection failure — possible runtime issue

  • Explanation: The interface exposes device 0 even when PyTorch detects no CUDA devices. A selectable index therefore does not prove CUDA is working, and device availability does not establish native DLSSG support.
  • Solution: Check the devices reported by AetherScale • Diagnostics and your ComfyUI startup log. Use an index that exists in that environment and verify that its PyTorch installation and GPU driver support the required processing.

Out-of-memory or allocation failure — possible runtime issue

  • Explanation: Long sequences, large images, and high multipliers can require substantial GPU memory, system memory, or output storage. The supplied class does not provide a memory-budget calculation.
  • Solution: Test fewer frames, lower the multiplier, and close other memory-heavy applications. Consider output_precision="float16", output_storage="mmap", and the default output_device="cpu_safe" where supported; these do not eliminate the backend's internal GPU-memory requirements.

Connected motion unavailable or not used — configuration issue

  • Explanation: Connected-motion processing needs a suitable packet, while motion_source="rgb_only" explicitly removes that packet before the backend receives it. The supplied class does not validate packet compatibility itself.
  • Solution: Connect an AETHERSCALE_MOTION packet generated from the corresponding sequence, choose the connected-motion route, and avoid rgb_only. For native processing, also check native_guide_source.

Memory-mapped output creation failure — possible storage issue

  • Explanation: A memory-mapped output path may fail if its backing location cannot be created or accessed, or if storage capacity is insufficient. The supplied class does not identify the backing location or exact error wording.
  • Solution: Inspect the backend error for the affected path, check free disk space and write permissions, and try output_storage="ram" on a small sequence if sufficient memory is available.

Invalid multiplier value — possible KeyError

  • Explanation: The node directly looks up the multiplier in a mapping containing only 2x, 3x, 4x, 5x, and 6x. An unsupported value supplied through an API or modified workflow can raise a KeyError before generation starts.
  • Solution: Restore one of the listed selections exactly, including the lowercase x. Normal dropdown selection prevents this mismatch.

Ghosting, repeated frames, or artifacts at cuts — visual issue rather than a confirmed exception

  • Explanation: Blending can show overlapping outlines, repetition can appear less smooth, and guidance across unrelated shots can produce unsuitable intermediate images. These symptoms do not necessarily mean execution failed.
  • Solution: Compare a short affected section with different surrogate methods or cut strategies. Check motion connections and native guide selection, then adjust protection controls or the native cut threshold one at a time while reviewing the result.

Incorrect playback speed after video assembly — timing configuration issue

  • Explanation: This node returns images, not a finished video with a guaranteed playback rate. Encoding an expanded sequence at the original frame rate can lengthen its duration rather than only increasing smoothness.
  • Solution: Set source_frame_rate to the actual source rate, inspect the returned sequence, and configure the downstream video frame rate for your intended duration. Use source rate multiplied by the requested factor as a nominal starting point, then verify the final timing.

AetherScale • MFG Related Nodes

Go back to the extension to check out more related nodes.
ComfyUI-AetherScale
RunComfy
Copyright 2025 RunComfy. All Rights Reserved.

RunComfy is the premier ComfyUI platform, offering ComfyUI online environment and services, along with ComfyUI workflows featuring stunning visuals. RunComfy also provides AI Models, enabling artists to harness the latest AI tools to create incredible art.

AetherScale • MFG