Predator media campaign · October 2026 · Edited 21 October 2026

Images, music, and the limits of video on a 6 GB GTX 1060

A 6 GB gaming GPU can still do useful creative work, provided the workload and waiting time suit you. In this campaign, it was much easier to make a recognizable image than a convincing short video. The gallery preserves both the good samples and the defects, so you can decide what “useful” means for your project.

The counts describe different things. Accepted results comprise 139 images, 11 videos and two music clips. One additional locally generated image survives despite cancelled delivery. Two pairs of early image files share identical original bytes, so the 153 retained outputs represent 151 unique original media hashes. Contact sheets, the input reference image and synthetic codec fixtures are excluded from these generated-output totals.

Open all retained images, videos, music and failed attempts. Each result includes its prompt, seed, settings and recorded timing.

One machine, through a real application

The recorded setup was Windows 10, a GTX 1060 with 6 GB dedicated VRAM and approximately 28 GiB system RAM, running ComfyUI 0.42.1. Packet Foundry routed the requests, ran them and collected their outputs. LangSmith recorded attempts and saved media attachments.

Two clocks appear in this article. Factory trace time includes adapter work, loading, execution and polling. Native time measures the Comfy graph itself. They have different boundaries, so compare figures carrying the same label.

Other device workloads, operating-system caches and some background downloads remained present. These are observations of a working setup. Different architectures, step counts and runtime state prevent treating the tables as an equal-quality model race.

Images: a full study, beyond the best-looking sample

We gave FLUX.3 klein SD Q4_K_M fifty briefs covering ten scene families, each at five levels of detail. Each brief ran twice, using seeds 42 and 43, producing 100 retained images with no failed or cancelled request in that study. Settings were 512 × 512, four Euler steps and CFG 1.

The briefs ranged from 16 to 463 words: a fox crossing a creek, tea by a rainy window, a botanical library and a paper ocean were among the scenes. The recorded thumbnail review found recognizable scene families in all 100 images. Exact text, anatomy and every requested detail were not formally scored.

The first request after launching the process took about four minutes. Most later requests reused a loaded model, and every second seed variant reused the brief's text encoding. That distinction explains why “cold” and “warm” need a precise meaning.

Longer, more detailed briefs tended to take longer, but several things changed together. We did not establish a seconds-per-word rule or prove that longer prompts made better images.

Want another variation? Keep the prompt and runtime together

Changing the seed gives another image from the same brief. In all fifty FLUX pairs, the second request reused both positive and negative text conditioning while sampling ran again; every pair produced two different retained images.

After excluding the initial-load pair, the 49 remaining pairs had a first-image native median of 70.05 seconds and a second-image median of 38.49 seconds. The median within-pair saving was 32.12 seconds. These native times differ from the Factory trace statistics above.

This suggests a useful workflow: keep a brief's seed variations together on the same running factory and profile. The cache lives in that runtime. Changing the composed prompt, switching models or factories, restarting or evicting cached state can remove the benefit. We measured two variations per brief; we did not measure a five-image batch.

Qwen Turbo also benefited from a repeated brief

We added ten Qwen Image 2.1 Turbo Q4_K_M images at 512 × 512, eight Euler steps, CFG 1 and the recorded ManualSigmas schedule. All ten files passed delivery, checksum and decode checks. The original images were also reviewed, with their material, geometry and prompt-following defects kept beside them in the gallery.

The first image took 320.246 seconds native, including loading and encoding. The next seed of the same brief took 95.234 seconds, after a 34.322-second gap. Eight subsequent new briefs had a median of 199.712 seconds, ranging from 194.865 to 223.135. A cached variation's time should therefore not stand in for the time needed by a new brief.

The first-to-second change combines initial loading and text-cache reuse; it does not isolate the text cache alone. The ten outputs also passed actual saved-attachment retrieval and the native ten-case experiment check. Inspect the ten Q4 images or read the pair and cache evidence.

Q4 versus Q8: more precision did not guarantee a better result

We repeated the same ten prompts and seeds with Q8_0 generator weights, keeping the eight-step settings, CPU encoder/VAE and FP32 computation. The eight new briefs had a median native time of 446.477 seconds with Q8, compared with 199.712 seconds with Q4. The cached second seed was much closer: 93.391 versus 95.234 seconds.

The runs happened at different times, with different inherited loading and cache state. An interruption also left a long gap between two Q8 cases, although the generation completed and its saved result was collected. The measurements show this setup's elapsed times; they do not isolate a causal speed penalty from changing quantization.

More stored weight precision is not an aesthetic score. Both sets have visible defects, and Q4 is not a high-precision ground truth. Compare the ten image pairs or download their exact timing and cache context.

Q2: a smaller generator, with a different loading policy

A further ten Q2_K images used the same prompts, seeds and sampling settings. This run also started a new Comfy process, changed the loading policy and added memory instrumentation. Its timing differences therefore cannot be credited to the smaller quant alone.

The recorded parameter checks placed the generator on CUDA, and peak Torch allocated memory was 3.278 GiB. Windows memory sampling had gaps and query errors. Those observations do not prove that every weight remained in physical dedicated VRAM for the entire run. All ten retained outputs passed the recorded delivery and file checks; their visual defects remain visible.

Inspect the Q4/Q8/Q2 image triples or download the matched timings and memory observations.

Music: two usable clips, about eleven minutes each

YuE2 INT8 ConvRot produced two 15-second stereo FLAC clips at 48 kHz. Factory traces took 700.26 and 634.17 seconds: 11 minutes 40 seconds and 10 minutes 34 seconds. Native graph durations were 696.921 and 630.994 seconds.

The user listened to both files and judged both usable music. That is a judgment about these two samples. We did not score lyric accuracy, genre fidelity or comparative musical quality. Successful decoding and clean signal checks cannot replace listening.

An earlier CPU semantic-generation trial was cancelled before producing audio. Moving that stage to the GPU made complete samples possible. The recorded semantic-generation and conditioning stages still dominated, at about 586 and 558 seconds; acoustic sampling and CPU decoding were smaller portions. The runtime retained loader state, but the second request changed style wording and seed, so those generation stages ran again.

Video: the file can finish while the scene still fails

Every accepted video below is 512 × 320, but length, frame rate, architecture and settings differ. Treat these as records of the tested configurations.

Wan: the baseline fox barely changed in inspected samples. The Q8 clips showed motion with shape inconsistencies. One follow-up was cancelled after the first baseline's hour-long wait. The second Q8 request followed an idle gap of roughly fifty minutes, so cached conditioning alone does not make it an immediate warm-run comparison.

LTX: the distilled configuration was much faster, using a single base-resolution pass rather than the official multiscale/upscaling pipeline. Its runtime stayed loaded from the text tests into the image-conditioned tests. Sampled frames showed recognizable foxes, but direction, anatomy and continuity still failed. Fast completion did not establish a usable walking sequence.

CogVideoX: after an initial attention-allocation failure, the first completed pair was colored noise. A source audit found differences from the reference implementation in positional embeddings, diffusion coordinates, noise schedule and solver. Correcting the bridge while retaining the same Q8 weights removed the noise in sampled frames. This does not isolate which change fixed it or justify blaming quantization alone.

The corrected Cog clips still missed the requested full-body walk: one fox exited and reappeared with a tail-like defect; the other was mostly empty snow with a cropped fox. Reviews sampled five frames per clip. Continuous, full-rate natural motion remains unverified. The corrected pair used the same runtime with a 46.902-second gap; the second request reused conditioning while sampling and decoding ran again.

Why a smaller model file does not guarantee a fast video

Q8 describes stored generator weights. These Pascal-compatible runs still computed in FP32, with separate precision and placement choices for other components. Quantizing a checkpoint does not shrink every activation or remove the work of a slow sampler.

Loading stages separately helps memory pressure, but it is not proof that the active stage fits entirely in dedicated VRAM. In the corrected Cog run, generator peak allocated memory was about 2.73 GiB, while decoder reserved memory reached about 7.52 GiB. Allocated and reserved memory are different counters, and Windows may page CUDA memory. We did not measure isolated kernel times or demonstrate a causal quantization speedup.

The unsuccessful attempts are part of the result

MiniMax H3 produced no accepted media. Its first native attempt failed while opening an approximately 27 GB text encoder, with Windows error 1455 at the file-open/mapping path. That indicates a paging-file capacity failure there, rather than a demonstrated GPU out-of-memory failure. A later dynamic-loading attempt went further but was cancelled by the user because it was too slow. Neither attempt establishes a completion time.

The archive also retains the cancelled YuE2 CPU trial, Cog's initial attention failure, two LTX storage-guard cancellations, an interrupted Qwen delivery and the cancelled Wan follow-up. Some stopped before generation; one produced local media without completing delivery. Those statuses remain distinct.

Accepted results passed checksum, full-decoding, collection and acknowledgement checks. Saved LangSmith attachment bytes were independently decoded, and native experiment exports were checked where recorded; the media-player UI was not separately inspected. The noisy Cog clips passed file checks while failing visual usefulness. Both facts belong beside the files.

Browse the complete campaign · How we measure · More findings