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

ComfyUI Extension: ComfyUI-AetherScale

Repo Name

ComfyUI-AetherScale

Author
vizart-vj (Account age: 2430 days)
Nodes
View all nodes(1)
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

ComfyUI-AetherScale Description

ComfyUI-AetherScale offers NVIDIA-powered nodes for image and video upscaling, restoration, HDR-style enhancement, frame generation, and memory-efficient video processing and export.

ComfyUI-AetherScale Introduction

[AetherScale screenshot showing the extension in ComfyUI](ex.png)

ComfyUI-AetherScale is a Windows/NVIDIA-focused collection of ComfyUI nodes for enhancing images, restoring video, generating additional frames, and exporting finished videos. Its current version is 0.9.2.

If you create AI animations, upscale generated clips, or prepare video for editing, AetherScale brings several stages of that process into one node pack:

  • Enlarge images and video with NVIDIA VFX Super Resolution.
  • Clean up footage with artifact reduction, denoising, and deblurring.
  • Adjust tone and color with a built-in CUDA HDR-style enhancer.
  • Analyze motion and scene changes for workflows that use information from neighboring frames.
  • Experiment with DLSS 5 Neural Rendering, subject to hardware, driver, and runtime compatibility.
  • Generate intermediate frames with native NVIDIA DLSS Frame Generation.
  • Load and process longer videos with less peak memory use by working in small pieces.
  • Export videos efficiently using NVENC, x264, or ProRes, with optional audio and workflow metadata.

AetherScale is particularly useful when a video is too large to comfortably hold as a complete, full-precision image batch in memory. Rather than treating every frame as one enormous block, many of its paths process frames incrementally and keep large results in memory-mapped storage.

Development status: The NVIDIA VFX enhancement nodes are the stable part of the project. DLSS 5 Neural Rendering remains experimental. Do not assume that every NVIDIA RTX card supports every backend.

Supported environment

AetherScale targets:

  • Windows 10 or Windows 11, 64-bit.
  • An NVIDIA RTX GPU.
  • A current NVIDIA display driver.
  • ComfyUI with Python 3.10 or newer.
  • Internet access for optional first-use runtime downloads, or the corresponding official pinned archives available locally.

RTX 50-series hardware is the primary target for the stock experimental Neural Rendering runtime. Support on other GPU generations depends on the selected runtime path.

How ComfyUI-AetherScale Works

It treats a video as a sequence of images

In ComfyUI, video processing commonly works with an IMAGE batch: a sequence of frames passed between nodes. AetherScale can load a video into that format, enhance its frames, and turn the result back into a video file.

A typical workflow looks like this:

Video Loader
    ↓
Restoration and/or Super Resolution
    ↓
Optional HDR-style enhancement
    ↓
Video Combine

You do not need every stage. For example, if your footage is already clean, you might use only Super Resolution and Video Combine.

It works in small pieces to limit memory pressure

Imagine editing a large book by placing only a few pages on your desk at a time. AetherScale uses a similar approach: where supported, it loads or processes a small group of frames instead of placing the entire video in GPU memory at once.

Three kinds of storage matter:

ResourceWhat it means for your workflow
VRAMMemory on your NVIDIA GPU. Enhancement and rendering operations use it while processing frames.
RAMYour computer’s main memory. Ordinary decoded video batches can consume a large amount of it.
File-backed or memory-mapped storageA file that ComfyUI can access like an image batch without requiring the whole sequence to remain in RAM at once.

AetherScale can also use FP16, a more compact numerical format than FP32. FP16 uses approximately half as much storage for the same number of image values.

For example, the author reports that a 15-second, 2464 × 512 video at 24 FPS occupies approximately:

  • 5.08 GiB as an RGB FP32 batch.
  • 2.54 GiB as RGB FP16 backing storage.

This does not make large videos free to process: disk space, GPU memory, and downstream nodes still matter. It does reduce the need to keep the entire sequence in working RAM.

Upscaling, Neural Rendering, and frame generation do different jobs

These features are related, but they are not interchangeable:

ProcessWhat changesWhich node to use
Super ResolutionEnlarges the image dimensions using NVIDIA VFX processing.Super Resolution
RestorationReduces noise, artifacts, or blur.Restoration
HDR-style enhancementChanges tone, contrast, saturation, and highlight treatment.HDR
Neural RenderingApplies the experimental DLSS 5 Neural Rendering path.Neural Rendering
Frame generationAdds intermediate frames between source frames.MFG or MFG Video

Important: Neural Rendering’s scale modes above native_1x use a GPU bicubic resize before Neural Rendering when using native_interop. This is not DLSS Super Resolution. Use the separate Super Resolution node for NVIDIA VFX upscaling.

Motion analysis helps identify movement and cuts

Motion analysis estimates how image content moves between the current frame and the previous frame. Scene-cut detection identifies transitions where the next frame belongs to a different shot rather than a continuous movement.

For Neural Rendering, the connected AetherScale motion packet currently supplies scene-cut reset timing. Its optical-flow tensor is not passed into the native Neural Rendering bridge.

Native frame generation has its own recommended internal motion guide, so it does not require the separate Motion Analysis node for its default workflow.

ComfyUI-AetherScale Features

Available nodes

NodeWhat you use it for
AetherScale • Video LoaderLoad video in small chunks into file-backed image storage, with audio, frame count, FPS, and statistics outputs.
AetherScale • Super ResolutionUpscale images or video using NVIDIA VFX, with streaming and long-video storage handling.
AetherScale • RestorationReduce artifacts, noise, and blur.
AetherScale • HDRApply CUDA-based HDR-style tone and color adjustments.
AetherScale • Motion AnalysisEstimate current-to-previous motion and detect scene cuts.
AetherScale • Neural RenderingRun experimental DLSS 5 Neural Rendering with chunking and fallback options.
AetherScale • Neural VRAM PlannerPlan memory requirements for Neural Rendering workloads.
AetherScale • MFGGenerate intermediate frames and return them as an IMAGE batch for further processing.
AetherScale • MFG VideoGenerate frames and send them directly to the video encoder, avoiding a large multiplied image batch.
AetherScale • Video CombineTurn an existing image batch and optional audio into a video file.
AetherScale • RuntimeInspect, bootstrap, repair, or clear AetherScale’s private runtimes.
AetherScale • DiagnosticsReport GPU, CUDA, runtime, and capability information.

Low-RAM video loading

Video Loader addresses a common bottleneck: an ordinary loader may fill RAM with the entire decoded video before an enhancement node can begin working.

AetherScale’s loader instead:

  1. Decodes a small group of frames with FFmpeg.
  2. Converts only that group to the selected precision.
  3. Writes it sequentially to a backing file.
  4. Maps the completed file as a ComfyUI IMAGE tensor after decoding finishes.

Recommended starting settings:

precision = auto
decode_chunk_frames = 4
force_rate = 0
frame_load_cap = 0
load_audio = true
clean_cache = true
SettingMeaning
precision = autoAutomatically chooses precision, selecting FP16 for large videos.
decode_chunk_frames = 4Decodes four frames at a time, keeping the working chunk small.
force_rate = 0Preserves the source frame rate.
frame_load_cap = 0Loads the full source instead of limiting the number of frames.
start_timeLets you begin decoding from a chosen point in the video.
load_audioEnables optional audio extraction.
path_overrideAccepts an absolute file path instead of choosing a video under ComfyUI/input.

The loader outputs:

  • IMAGE
  • frame_count
  • AUDIO
  • A VHS_VIDEOINFO-compatible information dictionary
  • Direct frame_rate
  • JSON statistics

Its first four outputs follow the common VHS loader arrangement, making it easier to substitute into an existing workflow. The direct frame_rate output is convenient for connecting to Video Combine.

The loader also checks disk space before decoding, reports progress, and responds to ComfyUI interruption requests.

Super Resolution and restoration

Use Super Resolution when you want larger output dimensions through NVIDIA VFX processing. The node supports incremental processing and large-output storage handling rather than requiring the entire sequence to reside on the GPU.

Use Restoration when your source has visible noise, compression artifacts, or blur. It provides artifact reduction, denoising, and deblurring workflows.

For a first upscaling workflow, the author recommends starting with Super Resolution and its automatic memory controls.

HDR-style tone and color enhancement

The HDR node uses AetherScale’s built-in CUDA enhancer. Current NVIDIA Video Effects SDK releases do not expose a public HDR effect for this purpose.

Its controls include:

  • Profile: balanced, cinematic, punchy, or natural.
  • Strength: Controls how strongly the enhancement is applied.
  • Saturation: Adjusts color intensity.
  • Contrast: Adjusts tonal separation.
  • Highlight preservation: Controls the treatment of bright image areas.

For example, you can compare profiles on the same short clip, then adjust strength and saturation to suit your artwork. This is especially useful when deciding how much enhancement a stylized animation needs.

HDR-style is not the same as an HDR-mastered file. The node outputs normalized ComfyUI image tensors. It does not attach HDR10/PQ mastering metadata.

AetherScale is designed to automatically select a compatible native NVIDIA VFX HDR effect if a future runtime exposes one.

Temporal analysis for longer sequences

Motion Analysis provides motion estimation and scene-cut detection. Its compact motion storage uses FP16 to reduce the size of motion data for long sequences.

For Neural Rendering workflows, use:

motion_mode = compact_flow

This is the recommended starting point for longer videos.

For native MFG, the author instead recommends the internal motion guide described below. The separate Motion Analysis node is not a required step for that default path.

Experimental DLSS 5 Neural Rendering

The default Neural Rendering backend is:

backend = native_interop

It runs inside the ComfyUI process and connects CUDA processing with a D3D12/NGX native bridge. In practical terms, AetherScale manages the frame chunks, GPU selection, output storage, progress reporting, scene resets, and fallback behavior around that bridge.

A recommended starting workflow is:

Source images or video frames ─────────────→ Neural Rendering
                └→ Motion Analysis ───────→ motion input

Start at the source resolution:

upscale_mode = native_1x

The author provides these starting settings for a 16 GB RTX 50-series GPU:

backend = native_interop
native_chunk_frames = 8
native_fallback = carrier
output_precision = auto
output_storage = auto
clean_cache = true

native_chunk_frames is an upper limit, not a guaranteed batch size. AetherScale can reduce the active chunk when less VRAM is available than expected.

Available backend roles are:

BackendIntended role
native_interopDefault in-process Neural Rendering path.
carrierExplicit compatibility fallback.
legacy_directDiagnostics and reproducing earlier behavior, rather than the preferred production path.

The carrier backend follows Windows graphics-adapter routing rather than PyTorch CUDA numbering. AetherScale applies a per-application High Performance GPU preference to its worker and reports the expected adapter in statistics.

For architectural details, see Native Neural Rendering interop design.

Native DLSS Frame Generation

MFG generates intermediate frames between existing frames. This can support smoother playback or slow-motion workflows, depending on the frame rate used when exporting.

The native backend has been the default since v0.8.0:

mode = native_dlssg

The author recommends these initial native settings:

multiplier = 4x
native_guide_source = internal_dis
native_auto_bootstrap = true
native_scene_cut_threshold = 0.24

The 4x setting is the author’s suggested first test on RTX 50-series hardware, not a guarantee of support on every GPU.

Understanding multipliers

For a 24 FPS source:

  • 2x corresponds to a 48 FPS output timeline.
  • 3x corresponds to a 72 FPS output timeline.
  • 4x corresponds to a 96 FPS output timeline.

Saving a 4x generated sequence at 96 FPS preserves its original duration. Saving those frames at 24 FPS produces 4x slow motion.

The exposed multiplier range is 2x–6x. The native worker reports its supported multi-frame count at runtime. If the requested multiplier is not directly supported, AetherScale uses enough native 2x stages to create a denser sequence, then selects frames for the requested output timeline.

Internal motion guide

The recommended internal_dis guide analyzes a grayscale version of the current frame at approximately 640 pixels wide, estimates current-to-previous motion with OpenCV DIS Medium, and supplies a full-resolution FP16 motion field to DLSSG.

You do not need to configure those internal steps individually. The practical recommendation is to keep internal_dis unless you are specifically experimenting with connected motion.

Legacy mode

surrogate_mv remains available for reproducing pre-v0.8 results and debugging.

Controls such as artifact_guard, emissive_protection, thin_detail_protection, mv_confidence_threshold, fallback_mode, and synthesis_mode belong to that older path. They do not affect native DLSSG processing.

Choosing MFG or MFG Video

Use MFG when you need generated frames as an IMAGE batch—for example, to inspect them or send them through more image-processing nodes.

Use MFG Video when your next step is a finished video file.

Source IMAGE batch
    ↓
Native frame generation
    ↓ one frame at a time
FFmpeg / NVENC
    ↓
MP4 output

MFG Video avoids creating the full multiplied frame sequence as a ComfyUI image batch. For large, high-resolution jobs, that can avoid tens or hundreds of GiB of intermediate storage.

Connect the original source FPS to source_frame_rate. MFG Video automatically encodes at:

source_frame_rate × multiplier

This preserves the source duration.

Video Combine: general-purpose video export

Use Video Combine when you already have an IMAGE batch and want to encode it. This includes images produced by AetherScale, RIFE, or another image-producing node.

The node packs frames into bounded chunks and prepares the next chunk while FFmpeg processes the current one. This reduces unnecessary copying and avoids requiring an additional full-video encoding buffer.

Recommended starting settings:

codec = h264_nvenc
preset = p3
bitrate_mbps = 20
pixel_format = yuv420p
chunk_mb = 64
pipeline_depth = 2
  • p3 favors speed.
  • p4 offers somewhat better compression efficiency.
  • 20 Mbps is a starting point for typical 1080p-like output; increase it for higher resolutions or highly detailed content.
  • yuv420p is the recommended option for broad playback compatibility.

The node supports MP4, MKV, and MOV output paths with NVENC, x264, or ProRes options.

GPU selection for NVENC

nvenc_gpu selects from physical GPUs discovered through nvidia-smi. By default, Video Combine chooses the highest-generation NVIDIA GPU detected.

AetherScale isolates that adapter for the FFmpeg process and maps it to FFmpeg’s logical CUDA GPU 0. This helps avoid mismatches between physical GPU numbering and the restricted device list that ComfyUI may use.

ProRes for editing workflows

Select a prores_* codec profile when you need ProRes output.

AetherScale automatically:

  • Uses a .mov container.
  • Selects the matching prores_ks profile.
  • Uses yuv422p10le for 422 profiles.
  • Uses 10-bit 4:4:4 for 4444/XQ profiles, preserving alpha when supplied with a four-channel IMAGE.

The generic bitrate, NVENC GPU, and NVENC preset controls do not apply to ProRes.

An encoded ProRes file can be valid even if your browser cannot play it in the node preview.

Audio

Connect optional AUDIO to include sound. AetherScale writes a temporary PCM WAV and uses FFmpeg to mux AAC audio into the result. The temporary WAV is removed afterward.

audio_bitrate_kbps offers common AAC bitrates from 64 to 512 kbps.

Only the final audio-muxed video is saved by default. Enable save_silent_copy only if you also want a silent version; that copy is created without re-encoding the video.

Preview and temporary output

The encoded video appears inside the node.

With:

save_output = false

the preview file is written to ComfyUI’s temporary folder and remains viewable in the node.

Workflow and generation metadata

save_metadata and metadata_target control where workflow information is saved:

TargetResult
sidecar_jsonCreates <video>.metadata.json beside the video.
video_containerEmbeds workflow/prompt metadata in the video container.
bothSaves both forms.

When possible, AetherScale follows the upstream image connections to capture the nearest relevant seed/noise source, sampler, scheduler, and model loader.

You can supply or override values through:

  • seed
  • sampler_name
  • scheduler
  • model_name

Container metadata includes readable model, seed, sampler, and scheduler tags, plus a description summary and embedded JSON containing the full workflow/prompt metadata.

Long-video storage and cache behavior

On the large-output Super Resolution and Neural Rendering paths, clean_cache controls the output storage policy:

ValueBehavior
trueRecommended/default. Tries an anonymous/pagefile-backed mapping first, then falls back to temporary disk-backed storage if Windows cannot reserve enough commit memory.
falseUses a persistent disk-backed .mmap in .aetherscale_cache, useful for debugging or workflows that explicitly need persistent backing storage.

“Commit memory” is the amount of memory Windows can promise to applications, supported by RAM and the pagefile. If that limit is too low, AetherScale can spill to disk rather than immediately failing with WinError 1450.

Temporary spill files are marked for deletion when ComfyUI releases the output tensor. After a crash, PID-aware orphan cleanup removes abandoned temporary mappings during a later AetherScale cache operation or startup.

You can place cache and spill files on another drive by setting this environment variable before launching ComfyUI:

AETHERSCALE_CACHE_DIR

For video loading, the backing file is part of the low-RAM design. clean_cache = true should not be interpreted as “the Video Loader never writes to disk.”

Bounded disk writeback

AetherScale flushes large writes in bounded windows rather than allowing Windows to accumulate a huge backlog of unwritten file-cache data.

The default window is 128 MiB. Advanced controls are:

  • AETHERSCALE_SPILL_FLUSH_MB
  • AETHERSCALE_VIDEO_LOAD_FLUSH_MB, which takes precedence for video loading and otherwise falls back to the spill setting.

This helps progress reporting reflect actual storage throughput and reduces lengthy background writeback after an interrupted process.

Downstream nodes still matter. A node outside AetherScale may copy or materialize the full batch, undoing the memory savings of an earlier streaming stage.

Progress and interruption

Long-running stages report progress in both the terminal and ComfyUI’s browser interface.

A typical terminal display includes:

[AetherScale] Super Resolution | ... | 250/600 frames | 2.31 frame/s | ETA 02:31

Each stage maintains one live progress bar rather than printing a new line for every update. The bar adapts to the console width, and the final completed state remains as a single history line.

ComfyUI-AetherScale Runtimes and Compatibility

AetherScale’s documented processing choices are backends and runtimes, rather than a catalog of separately named artist-selectable models.

Depending on the node you use, it may load or bootstrap the following components:

ComponentPurpose
nvidia-vfx==0.1.0.1NVIDIA VFX enhancement processing.
Pinned MIT bridge/caller from orex2121/ComfyUI-DLSS5-orexDefault in-process Neural Rendering bridge.
Neural Rendering runtime 310.8.SF-v2Pinned runtime verified for that bridge when native automatic bootstrap is enabled.
Merserk/dlss5-visual-enhancer v1.0 portable releaseExperimental carrier backend.
Pinned MIT bridge/caller from lisitskyaa/ComfyUI-DLSS5-NR and selected DLSSNR packagesLegacy direct diagnostic path.
Pinned worker and DLSSG DLL from Konohamaru04/ComfyUI-NVIDIA-DLSS-Frame-InterpolationNative DLSS Frame Generation.

Runtime binaries are not stored in the Git repository. Downloaded pinned archives are checked against hard-coded SHA-256 values before use.

For native frame generation, automatic bootstrap retrieves:

  • dlssg-worker.exe
  • nvngx_dlssg.dll

These are stored under:

ComfyUI-AetherScale/runtime/dlssg_native/

The Runtime node lets you inspect, bootstrap, repair, or clear private runtimes without changing your artistic workflow.

See Third-party notices, sources, and checksums for exact dependency information and licensing.

What's New with ComfyUI-AetherScale

Version 0.9.2 — Stable Video Combine preview sizing

This update fixes a Video Combine interface problem where the node grew taller after repeated execution or UI interaction.

Changes include:

  • One persistent video-preview widget instead of repeatedly recreating the player.
  • Preview height calculated from the current node width and the actual video aspect ratio.
  • Re-running the node swaps the video source without accumulating layout changes.
  • Old workflows containing an abnormally tall Combine node are automatically refitted once after loading.

Why it matters: Your export node should remain manageable on the canvas, even after repeated previews and render attempts.

The author implemented this behavior in AetherScale’s own frontend code; VHS Video Combine was used only as a reference for stable preview behavior.

Version 0.9.1 — Low-RAM Video Loader

This release added AetherScale • Video Loader.

Its major changes were:

  • FFmpeg decoding in small chunks.
  • Sequential writes directly into a backing file instead of building a complete FP32 array first.
  • Automatic FP16 selection for large sources.
  • Mapping the finished file only after decoding completes.
  • Bounded 128 MiB writeback to reduce Windows file-cache buildup.
  • Early disk-space checks.
  • Decode progress and interruption handling.
  • Optional audio extraction.
  • start_time, frame_load_cap, and force_rate controls.
  • VHS-compatible information outputs and direct FPS output.

Existing node schemas remained compatible; the loader was added without replacing them. Documentation, package metadata, diagnostics, runtime identification, and release information were also synchronized for this release.

Why it matters: A memory-conscious enhancement chain can now begin with a memory-conscious loader, rather than running out of RAM before processing starts.

Version 0.8.0 and later — Native frame generation becomes the default

The documented change from v0.8.0 onward is that MFG uses native_dlssg by default.

  • Native generated frames can be returned directly as images.
  • MFG Video can stream generated frames directly to FFmpeg/NVENC.
  • surrogate_mv remains available for comparison and older workflows.
  • The historical AetherScaleMFGLab class ID is retained for workflow compatibility.

Why it matters: You can use native NVIDIA frame generation while preserving access to older workflows and debugging paths.

Troubleshooting ComfyUI-AetherScale

Loading a video causes a large RAM spike

  1. Check which node loads the source.
  2. Replace a whole-batch loader with AetherScale • Video Loader.
  3. Start with precision = auto and decode_chunk_frames = 4.
  4. Confirm that the cache drive has enough free space.
  5. Test a shorter segment using start_time and frame_load_cap.

A streaming enhancement node cannot recover memory already consumed by an upstream loader that decoded the whole video into RAM.

Processing fails with WinError 1450

This can indicate that Windows cannot reserve enough commit memory.

  1. On the relevant Super Resolution or Neural Rendering path, use clean_cache = true.
  2. Ensure the cache drive has enough free space for temporary spill storage.
  3. If necessary, set AETHERSCALE_CACHE_DIR to a drive with more available space before starting ComfyUI.
  4. Check whether a downstream node is copying the full output batch.
  5. For a large frame-generation export, use MFG Video instead of creating a multiplied IMAGE batch.

A frame-generation job needs enormous amounts of storage

  1. Decide whether you actually need the generated frames as an image batch.
  2. If the next step is a video file, switch to MFG Video.
  3. Connect the original FPS to source_frame_rate.
  4. Let MFG Video stream the generated frames directly to the encoder.

Even FP16 output can become extremely large when high-resolution footage is multiplied by 2x, 4x, or more.

Neural Rendering fails or behaves differently on another GPU

  1. Run Diagnostics and note the GPU, driver, CUDA, and runtime information.
  2. Confirm that the selected backend is suitable for your hardware.
  3. Begin with backend = native_interop and upscale_mode = native_1x.
  4. Use automatic output precision and storage.
  5. Treat native_chunk_frames as a ceiling; reduce it for a smaller initial test if necessary.
  6. Use the Runtime node to inspect or repair the relevant runtime.
  7. If appropriate, test the explicit carrier fallback.

RTX 50-series hardware is the primary target for the stock Neural Rendering runtime. Experimental runtime behavior is not uniform across all RTX generations.

Runtime downloads fail

AetherScale already tries multiple download methods on Windows: a direct connection, configured proxies, curl, and PowerShell.

For the carrier backend:

  1. Check whether the official DLSS.5.Visual.Enhancer.v1.0.zip is already in your Windows Downloads folder.
  2. If you have a local copy elsewhere, set AETHERSCALE_CARRIER_ARCHIVE before launching ComfyUI.
  3. Advanced users may use AETHERSCALE_CARRIER_URL for a mirror.
  4. Retry the runtime operation.

The pinned checksum is still verified. A different archive is not accepted merely because it has a matching filename.

The wrong GPU seems to be in use

GPU selection differs by backend:

  1. For VFX/CUDA operations, check CUDA device selection.
  2. For the carrier backend, check the expected adapter reported in statistics; it follows Windows D3D12/DXGI routing.
  3. For Video Combine, inspect nvenc_gpu and select the intended physical adapter.
  4. Use Diagnostics to record the visible GPUs before comparing behavior.

Do not assume that a GPU index in one subsystem refers to the same adapter in another.

MFG settings appear to have no effect

  1. Check whether you are using native_dlssg or surrogate_mv.
  2. If you are using native DLSSG, ignore the old artifact-guard and surrogate synthesis controls.
  3. Keep native_guide_source = internal_dis for the recommended native path.
  4. Use surrogate_mv only when reproducing earlier behavior or debugging.

The generated video plays too slowly or has the wrong duration

  1. Check the original source FPS.
  2. Check the frame-generation multiplier.
  3. If exporting an MFG image batch, encode at the multiplied FPS to preserve duration.
  4. If using MFG Video, supply the original FPS to source_frame_rate; it applies the multiplier automatically.

For example, 24 FPS footage generated at 4x needs a 96 FPS export to keep its original duration. Exporting those frames at 24 FPS creates slow motion.

A ProRes MOV does not play inside the node

  1. Confirm that encoding completed successfully.
  2. Open the MOV in a player or editor that supports ProRes.
  3. If you need broad playback compatibility, try H.264 with pixel_format = yuv420p.

Inline ProRes playback depends on the browser and operating system. A failed browser preview does not by itself mean the exported file is invalid.

Video Combine keeps growing vertically

  1. Check your AetherScale version.
  2. Use v0.9.2 or newer for the documented preview-sizing fix.
  3. Load the affected workflow; abnormally tall saved Combine nodes are refitted once after loading.

Cache files remain after a crash

  1. Allow a later AetherScale startup or cache operation to run its orphan cleanup.
  2. Check whether the workflow used persistent storage with clean_cache = false.
  3. Remember that temporary mappings are normally deleted only after ComfyUI releases the output tensor.

Persistent .mmap storage and temporary spill storage intentionally have different cleanup behavior.

Frequently asked questions

Does AetherScale work on AMD GPUs, macOS, or Linux?
The documented target is Windows 10/11 with an NVIDIA RTX GPU. Other platforms are not covered by the stated requirements.

Does the HDR node create a true HDR10 video?
No. It applies HDR-style tone and color enhancement and outputs normalized images without HDR10/PQ mastering metadata.

Is Neural Rendering’s 3x mode equivalent to DLSS Super Resolution?
No. Under native_interop, modes above native_1x use bicubic pre-resizing followed by Neural Rendering. Use Super Resolution for NVIDIA VFX upscaling.

Do I need Motion Analysis for native frame generation?
Not for the recommended default path. Native MFG uses internal_dis. Connected motion is available for experiments.

Does low-RAM processing mean no disk space is needed?
No. Video Loader uses backing storage, and other large-output paths may spill to disk. Plan for free space on the selected cache drive.

Can another node undo AetherScale’s memory savings?
Yes. A downstream node can copy or materialize a full image batch. Consider the whole workflow, not just the AetherScale stage.

Which export node should I choose?
Use MFG Video for a frame-generation job that goes directly to a file. Use Video Combine when you already have an image batch from any compatible node.

What information helps diagnose an experimental Neural Rendering problem?
Keep the GPU model or models, NVIDIA driver version, AetherScale version, full ComfyUI traceback, and AetherScale stats output when available.

Learn More about ComfyUI-AetherScale

For practical experimentation, begin with a short clip, preserve its source FPS, and test one enhancement stage at a time. Once the result is suitable, extend the workflow to longer footage using the low-RAM loader and the appropriate streaming export path.

ComfyUI-AetherScale License and Third-Party Software

AetherScale’s source code is licensed under the MIT License. Third-party runtimes and components retain their own licenses and terms; the project does not replace or relicense them.

AetherScale is an independent community project. It is not affiliated with or endorsed by NVIDIA, Topaz Labs, RenoDX, ReShade, or the referenced third-party projects.

See THIRD_PARTY_NOTICES.md for details.

ComfyUI-AetherScale Related Nodes

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.

ComfyUI-AetherScale detailed guide | ComfyUI