Make 4K AI Images Without an Upscaler: The MOSS-Image and NVIDIA PiD Workflow, and the Licence Line You Cannot Cross
Most AI images reach poster size the long way round. The model draws a picture at its comfortable size, then a separate upscaler stretches it and invents detail to fill the gaps. That second tool has never seen your prompt. It is guessing at texture for a picture it did not make.
A workflow posted to Hugging Face on October 30 skips that guess. It has an open image model compose a small picture in four steps, then hands the model's compressed, not-yet-pixels version of that picture to an NVIDIA decoder called PiD, which paints the final image at four times the width and four times the height in four more steps. Eight steps, and a 704 by 384 sketch comes out as a 2816 by 1536 image.
That is a real improvement in how you get to large sizes. It also comes with a licence line that matters more than the image quality, and you need to know where that line is before a client sees anything.
Why "small first, detail second" works
Picture a painter blocking in a canvas. They settle composition, light and colour at arm's length with a big brush. Fine detail comes last, up close.
Image models are expensive in the same way a big canvas is. The workload grows fast as the picture gets bigger, so generating directly at 4K is slow and often worse, because the model was trained to compose at smaller sizes.
The MOSS-Image and PiD pairing splits the job like the painter does. MOSS-Image, an open model from the OpenMOSS team under the permissive Apache 2.0 licence, works at a quarter of the final width and height. The workflow's author points out what that saves: at the default size, MOSS handles 1,056 pieces of image instead of 16,896. It settles the composition cheaply.
Then PiD takes over. Instead of turning MOSS's in-progress picture into pixels at the small size and stretching them, PiD paints the large image itself, working from the model's own compressed internal version of the picture, before it is turned into pixels, rather than from a flat, finished JPEG. It sees more of what the model meant, so the detail it adds has more to go on.
That is the position of this piece: compose small and let a decoder that understands the picture paint the detail. It is a better route to large images than "generate, then upscale," and this free workflow is the easiest way to feel the difference yourself.
What you get, in numbers that matter
Size. You set the small render in multiples of 16. PiD makes each side four times longer. The default turns 704 by 384 into 2816 by 1536. A square 512 by 512 becomes 2048 by 2048. At 300 dots per inch, the default's long side prints at a little over nine inches.
Steps. Four for composition, four for the final paint. The workflow ships with 100 example images, with prompts and the random starting number (seed) for each, so you can check your setup against the author's results.
Disk space. The listed model files total roughly 39 GB. The two big ones are the MOSS-Image model at 10.2 GB and the text reader that interprets your prompt at 19.3 GB. The README also lists smaller alternatives.
Speed. No timings are published. The design is clearly meant to be fast, but nobody has posted seconds-per-image yet, so measure on your own machine before you plan a deadline around it.
The licence line
Read this section before you install anything.
MOSS-Image, the four-step add-on and the workflow files are all Apache 2.0. You can use them commercially.
The PiD decoder files are not. They sit under NVIDIA's own source code licence, and NVIDIA's model card states that "the work and any derivative works may only be used for non-commercial (research or evaluation) purposes." The workflow author flags this directly in the README: the PiD files are "not Apache-2.0: read its terms before any use beyond them."
PiD's code on GitHub is Apache 2.0, which can confuse people. The code and the trained files are different things. The files are what paint your picture, and they carry the restriction.
In practice that means the 4K image this workflow produces is fine for testing, personal projects, studying how the method behaves, and showing a creative director "this is the direction" internally. It is not cleared for a client deliverable, a product page or anything you are paid for, unless NVIDIA gives you other terms.
I think this is the right way to use it anyway. Treat PiD as the reference for what a good enlargement should look like. Then, for paid work, render the same composition small with MOSS-Image, which you can use commercially, and enlarge it with a tool whose licence you have actually checked. If the commercial result looks worse, you have learned exactly what a better decoder would be worth to you.
Put this into practice
The workflow lives at lvladikov/MOSS-PiD-SuperFast-HighRes. There are two versions: MOSS-PiD-SuperFast-HighRes-ComfyUI-local.json for your own ComfyUI, and MOSS-PiD-SuperFast-HighRes-ComfyUI-cloud.json for Comfy Cloud, Comfy's hosted service.
1. Update ComfyUI. You need a recent version with MOSS-Image and PiD support built in. Comfy's own PiD tutorial warns that newly added core nodes can be missing from the latest stable release.
2. Download the files into your ComfyUI models folders. From Comfy-Org/MOSS-Image: moss_image_sft_bf16.safetensors, qwen3.5_9b_bf16.safetensors and flux2-vae.safetensors. From akhaliq's four-step repo: moss_image_sft_4step_v2.0.safetensors. From Comfy-Org/PixelDiT: pid_1.5_flux2_1024_to_4096_4step_bf16.safetensors and its small text file gemma_2_2b_it_elm_bf16.safetensors. The README tells you which folder each goes in.
3. On Comfy Cloud, most files are already hosted. You import two once (the four-step add-on and the PiD decoder), and the workflow expects the names Cloud gives them.
4. Leave the settings alone at first. The workflow ships with them set: four steps for each stage, the strength-of-prompt setting at 1, and no negative prompt. Change one thing at a time once you have a baseline.
5. Write long prompts. The README says MOSS-Image works best with long, specific scene descriptions. Describe the light, the lens feel, the materials and the mood, the way you would brief a photographer, not a list of tags.
6. Pick the right decoder for your size. The default decoder targets outputs from 2K to 4K. For finished images up to 2048 pixels on the long side, the README points to a smaller decoder, pid_flux2_512_to_2048_4step_bf16.
7. Compare against the examples. Run one of the author's 100 prompts with the listed seed. If your result looks clearly different, something in your setup is off.
How to judge the result
A 4K image always looks impressive on a laptop screen, because the screen throws away most of the pixels. Judge it the way a printer or an art director will.
Look at 100 percent. Zoom until one image pixel is one screen pixel and pan slowly across the picture. You are looking for detail that belongs to the subject: individual hairs, fabric weave, brick mortar. The failure to watch for is generic texture, the same busy pattern smeared across skin, stone and sky alike.
Check the edges. Where a dark object meets a bright sky, look for halos or a thin bright outline. Those are the classic signs of an image that was stretched rather than painted.
Compare against a plain enlargement. Take the small 704 by 384 render, enlarge it four times in any photo editor, and put it next to the PiD version. If you cannot tell them apart at 100 percent, the decoder is not earning its 2.8 GB on your subject.
Test text separately. Small lettering is where most models stumble. If your picture has signage or labels, check that the decoder sharpened the letters you asked for rather than inventing new ones.
Where it breaks
You cannot sell the output as is. The decoder's licence rules out commercial use. Everything else in this workflow is commercially usable, but that one file is the one that makes the 4K.
It is a big download. Around 39 GB before you make your first picture. On a slow connection, budget an evening.
No published speed figures. Fast in principle. Unmeasured in public.
The Python route is NVIDIA-only. The author's script needs an NVIDIA card. Mac users should use the ComfyUI workflows, which the README recommends for that case.
Bad compositions stay bad. PiD paints detail; it does not fix a weak layout. If the small picture is wrong, the 4K version is wrong in more pixels.
The decoder must match the model. Comfy's tutorial is clear that you need the PiD version built for the specific family of model that made the small picture. Mixing them up gives poor results.
What this changes about your process
The bigger lesson outlasts this workflow. The size at which you decide and the size at which you deliver are now two separate steps, each handled by a tool built for it. That mirrors how illustrators, retouchers and matte painters have always worked: rough small, finish large.
So try it this way. Spend your iterations at 704 by 384, where four steps cost almost nothing and you can explore twenty compositions in the time one large render used to take. Pick the one that works. Only then send it up to 4K.
And keep a note, for every image you love, of which files made it. When a client asks for that picture at poster size, you will want to know in ten seconds whether you are allowed to give it to them.