128 GB of Unified Memory in a Laptop: What Local Image Generation Actually Gains

For two years, if you wanted to run image models locally, you built a desktop. Big PSU, big case, one heavyweight graphics card, and a prayer that the next model release still fit in VRAM. Laptops were for reviewing what the desktop rendered.

The machines ASUS announced at IFA 2026 are the latest sign that this split is closing. The ProArt P14 and P16 are thin creator laptops built on NVIDIA's RTX Spark platform, with a Blackwell RTX GPU of up to 6,144 CUDA cores, a 20-core Arm-based Grace CPU, and a figure ASUS puts at up to one petaflop of FP4 AI compute. The number that actually matters for image work sits elsewhere in the spec: up to 128 GB of unified LPDDR5X memory, shared between CPU and GPU, in chassis weighing 1.48 kg for the P14 and 1.77 kg for the P16.

The Spanish press coverage that ran the full spec sheets frames these as cloud alternatives: run models up to 120 billion parameters, edit 12K 4:2:2 video, generate AI video in 4K, all without a subscription meter ticking. That framing deserves a closer look, because "local AI laptop" means very different things for text, for video, and for images.

Why unified memory changes the math

On a conventional Windows laptop, the GPU has its own 8 to 16 GB of VRAM, and that is the budget for keeping a model fast and resident. Image models want to fit inside it, weights plus activations, and when they do not, you are into CPU or model offload: the pipeline still runs, but it crawls, because weights get shuffled across the PCIe bus. On a unified-memory machine there is one pool. The GPU can address nearly all of it, so the fast-resident budget moves from "biggest chip you can afford" to "how much RAM you ordered."

That single change reshuffles what fits:

• Diffusion models stopped being the constraint. A FLUX-class image model at FP8 is roughly 18 GB, and the full pipeline needs more than the checkpoint alone: text encoders and the VAE sit in memory alongside it. An FP8 configuration may fit within 24 GB at a chosen resolution, and peak use sits close enough to that limit that it varies with resolution and optimization; an 8 GB laptop GPU generally needs quantization or offload to run the pipeline at all. On 128 GB of shared memory, image models are small cargo.
• Long context stops being a text-only luxury. Feeding an editing model thirty reference images at full resolution to hold a character consistent across a set eats memory fast. The character consistency workflows people run in the cloud are, mechanically, large-context image jobs. Local machines with a big shared pool can run them offline.
• Fine-tuning becomes plausible on battery. Training a LoRA on a 12 GB card means tiny batches, aggressive gradient checkpointing, and long evenings. Not because the math is exotic, but because the working set does not fit. Larger pools relax exactly that pressure. We have walked through how to plan datasets for exactly these runs — dataset strategy, not hardware, is where the quality comes from.

The comparison point is Apple, not other Windows laptops. Apple Silicon pioneered this architecture, and current MacBook Pro configurations reach the same 128 GB. What RTX Spark adds is NVIDIA's software stack on top: CUDA software that already runs in datacenters, wrapped in a laptop. For anyone whose local tooling lives in CUDA terms — ComfyUI, PyTorch builds, quantized inference runtimes — that continuity is the actual news, more than any single benchmark.

What the spec sheet does not say

Three things keep this from being a simple "cloud is dead" story.

FP4 marketing numbers are the best case, not the plan. NVIDIA's up-to-one-petaflop figure assumes FP4 precision with sparsity, and it is a peak compute number, not evidence that every operation in an image pipeline runs in four bits. Real pipelines mix precisions; the useful throughput lands well below the sticker. The figure is a ceiling, the same way megapixels are a ceiling for cameras.

Offload is not free. Unified memory means the GPU can use nearly all of RAM, but LPDDR5X bandwidth is a fraction of dedicated GDDR7. A model that fits with headroom may still generate noticeably slower than on a desktop card whose memory is simply faster. Fitting and running well are different sentences. The first-generation ComfyUI speed workarounds for video models each target a different wall: quantization cuts memory use, distilled LoRAs cut denoising steps, attention optimizations cut memory and execution overhead. All three were answers to laptop-class hardware, where the binding constraint was usually bandwidth or capacity, not one single factor. The techniques that made MiniMax H3 fit on an RTX 3060 are the same physics.

The software question is unsolved and boring. Grace is an Arm CPU. Windows-on-Arm runs x86 and x64 code through its Prism emulation layer, so your existing plugins probably launch. Probably. Professional creative stacks are full of plugins, drivers, and internal components still built for x86, and Microsoft itself recommends native Arm64 builds. Until these machines are in reviewers' hands, "my whole pipeline runs unchanged" is a hypothesis, not a fact. If your ComfyUI setup leans on custom nodes with prebuilt binaries, assume a compatibility pass before anything works.

A saner division of labor

None of that argues against the machines. It argues for using local capacity for the jobs where it wins:

• Iteration. Tens of prompt-and-seed cycles to find a direction cost real money on metered APIs. On local hardware they cost electricity and time. Exploration belongs where iteration is free.
• Private material. Client work, unreleased product shots, personal archives. Anything you cannot legally or comfortably ship to a third-party endpoint.
• Batch with a deadline you control. Overnight runs of variations, upscales, and dataset preparation. The AI-generated datasets trick for character LoRAs turns compute time into training data; local silicon makes the exchange rate visible.

And the cloud keeps the jobs where it wins: frontier video models too large for any laptop, burst scale when a deadline moves, and any model whose licensing forbids local weights.

The part that is genuinely new

Strip the marketing and one shift remains: memory capacity, the scarce resource of local AI, just became a laptop configurator option. Not a desktop tower. Not a Mac-only island. An option, next to storage, on a machine you can carry.

For image generation specifically, this lands at a useful moment. Image models are small enough that 128 GB removes capacity as a constraint for nearly everything except frontier video. The remaining walls are bandwidth, Arm compatibility, and price — the last one unannounced. When the constraint stops being "does it fit" and becomes "how fast does it run," the interesting question stops being hardware and returns to what it always was: what is worth generating.

That question does not care where the GPU lives. If you would rather not own the plumbing at all, hosted templates exist for that. But for the people who do want the whole stack on their desk — or in their backpack — the spec that finally made it real was not the petaflop. It was the memory line.