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:
| Resource | What it means for your workflow |
|---|---|
| VRAM | Memory on your NVIDIA GPU. Enhancement and rendering operations use it while processing frames. |
| RAM | Your computer’s main memory. Ordinary decoded video batches can consume a large amount of it. |
| File-backed or memory-mapped storage | A 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:
| Process | What changes | Which node to use |
|---|---|---|
| Super Resolution | Enlarges the image dimensions using NVIDIA VFX processing. | Super Resolution |
| Restoration | Reduces noise, artifacts, or blur. | Restoration |
| HDR-style enhancement | Changes tone, contrast, saturation, and highlight treatment. | HDR |
| Neural Rendering | Applies the experimental DLSS 5 Neural Rendering path. | Neural Rendering |
| Frame generation | Adds 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
| Node | What you use it for |
|---|---|
| AetherScale • Video Loader | Load video in small chunks into file-backed image storage, with audio, frame count, FPS, and statistics outputs. |
| AetherScale • Super Resolution | Upscale images or video using NVIDIA VFX, with streaming and long-video storage handling. |
| AetherScale • Restoration | Reduce artifacts, noise, and blur. |
| AetherScale • HDR | Apply CUDA-based HDR-style tone and color adjustments. |
| AetherScale • Motion Analysis | Estimate current-to-previous motion and detect scene cuts. |
| AetherScale • Neural Rendering | Run experimental DLSS 5 Neural Rendering with chunking and fallback options. |
| AetherScale • Neural VRAM Planner | Plan memory requirements for Neural Rendering workloads. |
| AetherScale • MFG | Generate intermediate frames and return them as an IMAGE batch for further processing. |
| AetherScale • MFG Video | Generate frames and send them directly to the video encoder, avoiding a large multiplied image batch. |
| AetherScale • Video Combine | Turn an existing image batch and optional audio into a video file. |
| AetherScale • Runtime | Inspect, bootstrap, repair, or clear AetherScale’s private runtimes. |
| AetherScale • Diagnostics | Report 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:
- Decodes a small group of frames with FFmpeg.
- Converts only that group to the selected precision.
- Writes it sequentially to a backing file.
- Maps the completed file as a ComfyUI
IMAGEtensor 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
| Setting | Meaning |
|---|---|
precision = auto | Automatically chooses precision, selecting FP16 for large videos. |
decode_chunk_frames = 4 | Decodes four frames at a time, keeping the working chunk small. |
force_rate = 0 | Preserves the source frame rate. |
frame_load_cap = 0 | Loads the full source instead of limiting the number of frames. |
start_time | Lets you begin decoding from a chosen point in the video. |
load_audio | Enables optional audio extraction. |
path_override | Accepts an absolute file path instead of choosing a video under ComfyUI/input. |
The loader outputs:
IMAGEframe_countAUDIO- 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, ornatural. - 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:
| Backend | Intended role |
|---|---|
native_interop | Default in-process Neural Rendering path. |
carrier | Explicit compatibility fallback. |
legacy_direct | Diagnostics 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
p3favors speed.p4offers somewhat better compression efficiency.- 20 Mbps is a starting point for typical 1080p-like output; increase it for higher resolutions or highly detailed content.
yuv420pis 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
.movcontainer. - Selects the matching
prores_ksprofile. - Uses
yuv422p10lefor 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:
| Target | Result |
|---|---|
sidecar_json | Creates <video>.metadata.json beside the video. |
video_container | Embeds workflow/prompt metadata in the video container. |
both | Saves 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:
seedsampler_nameschedulermodel_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:
| Value | Behavior |
|---|---|
true | Recommended/default. Tries an anonymous/pagefile-backed mapping first, then falls back to temporary disk-backed storage if Windows cannot reserve enough commit memory. |
false | Uses 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_MBAETHERSCALE_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:
| Component | Purpose |
|---|---|
nvidia-vfx==0.1.0.1 | NVIDIA VFX enhancement processing. |
Pinned MIT bridge/caller from orex2121/ComfyUI-DLSS5-orex | Default in-process Neural Rendering bridge. |
Neural Rendering runtime 310.8.SF-v2 | Pinned runtime verified for that bridge when native automatic bootstrap is enabled. |
Merserk/dlss5-visual-enhancer v1.0 portable release | Experimental carrier backend. |
Pinned MIT bridge/caller from lisitskyaa/ComfyUI-DLSS5-NR and selected DLSSNR packages | Legacy direct diagnostic path. |
Pinned worker and DLSSG DLL from Konohamaru04/ComfyUI-NVIDIA-DLSS-Frame-Interpolation | Native 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.exenvngx_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, andforce_ratecontrols.- 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_mvremains available for comparison and older workflows.- The historical
AetherScaleMFGLabclass 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
- Check which node loads the source.
- Replace a whole-batch loader with AetherScale • Video Loader.
- Start with
precision = autoanddecode_chunk_frames = 4. - Confirm that the cache drive has enough free space.
- Test a shorter segment using
start_timeandframe_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.
- On the relevant Super Resolution or Neural Rendering path, use
clean_cache = true. - Ensure the cache drive has enough free space for temporary spill storage.
- If necessary, set
AETHERSCALE_CACHE_DIRto a drive with more available space before starting ComfyUI. - Check whether a downstream node is copying the full output batch.
- For a large frame-generation export, use MFG Video instead of creating a multiplied
IMAGEbatch.
A frame-generation job needs enormous amounts of storage
- Decide whether you actually need the generated frames as an image batch.
- If the next step is a video file, switch to MFG Video.
- Connect the original FPS to
source_frame_rate. - 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
- Run Diagnostics and note the GPU, driver, CUDA, and runtime information.
- Confirm that the selected backend is suitable for your hardware.
- Begin with
backend = native_interopandupscale_mode = native_1x. - Use automatic output precision and storage.
- Treat
native_chunk_framesas a ceiling; reduce it for a smaller initial test if necessary. - Use the Runtime node to inspect or repair the relevant runtime.
- If appropriate, test the explicit
carrierfallback.
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:
- Check whether the official
DLSS.5.Visual.Enhancer.v1.0.zipis already in your WindowsDownloadsfolder. - If you have a local copy elsewhere, set
AETHERSCALE_CARRIER_ARCHIVEbefore launching ComfyUI. - Advanced users may use
AETHERSCALE_CARRIER_URLfor a mirror. - 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:
- For VFX/CUDA operations, check CUDA device selection.
- For the carrier backend, check the expected adapter reported in statistics; it follows Windows D3D12/DXGI routing.
- For Video Combine, inspect
nvenc_gpuand select the intended physical adapter. - 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
- Check whether you are using
native_dlssgorsurrogate_mv. - If you are using native DLSSG, ignore the old artifact-guard and surrogate synthesis controls.
- Keep
native_guide_source = internal_disfor the recommended native path. - Use
surrogate_mvonly when reproducing earlier behavior or debugging.
The generated video plays too slowly or has the wrong duration
- Check the original source FPS.
- Check the frame-generation multiplier.
- If exporting an MFG image batch, encode at the multiplied FPS to preserve duration.
- 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
- Confirm that encoding completed successfully.
- Open the MOV in a player or editor that supports ProRes.
- 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
- Check your AetherScale version.
- Use v0.9.2 or newer for the documented preview-sizing fix.
- Load the affected workflow; abnormally tall saved Combine nodes are refitted once after loading.
Cache files remain after a crash
- Allow a later AetherScale startup or cache operation to run its orphan cleanup.
- Check whether the workflow used persistent storage with
clean_cache = false. - 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
- ComfyUI-AetherScale repository — The project source and main reference for the extension.
- Workflow screenshot — A visual overview of AetherScale in ComfyUI.
- Native Neural Rendering interop design — A deeper technical explanation of the experimental native rendering architecture.
- Third-party notices — Dependency sources, checksums, licenses, and runtime details.
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.
