Best Local AI Image Generators: Choose by Hardware and Workflow

Published on October 18, 2026 by Steven Jones

The best local AI image generator depends on your computer, the application, and a compatible model. Our starting picks are Draw Things for a native Mac workflow, InvokeAI for canvas editing and ComfyUI for saved, inspectable workflows. Below, we match those applications to hardware, show a reproducible starter configuration and explain how to check that generation really works offline.

If you prefer an online option without installing models, the DIY AI Image Generator provides a browser-based workflow. For generation that must stay on your computer, use the local configurations below.

Choose a complete setup that fits your hardware

Your hardware and priority	Recommended starting setup	First configuration	Main trade-off
Apple Silicon Mac; prefer a conventional application	Draw Things + SDXL, using local compute	One 1024 x 1024 image. We would start with 16GB unified memory or more.	A native interface with fewer workflow connections to manage; larger models compete with macOS and other apps for shared memory.
Windows or Linux PC with a supported NVIDIA GPU; limited memory	ComfyUI + Stable Diffusion 1.5	512 x 512, batch size 1. A sensible first experiment in the 4-6GB VRAM band.	A small, understandable baseline with older image-generation capabilities.
Windows or Linux PC with a supported GPU; editing selected areas matters most	InvokeAI + SDXL, installed locally	1024 x 1024, one image. Invoke’s published guidance is 8GB VRAM and 16GB system RAM.	The canvas makes masks and editing areas accessible; you still need a compatible graphics backend and local model.
Supported GPU with more memory; want modern reference-image edits	ComfyUI + FLUX.2 [klein] 4B distilled FP8	Use the matching distilled template, around 1024 x 1024, one output. Check the complete pipeline’s memory requirements.	Text-to-image and reference editing in one model, but several model files and more configuration to understand.
Already paint in Krita; want generation inside that workflow	Krita + AI Diffusion plugin + local managed ComfyUI server + SDXL	Start with a small selection and the SDXL workload.	Selections and layers suit painting, but the application, plugin, backend and model must all match.

These are recommendations by workflow. The Mac memory suggestion and ComfyUI memory band are editorial starting points, not measured minimums. SD1.5 is useful for proving an installation works; SDXL is an established baseline. Neither should be mistaken for a claim about the best image quality available today.

For Krita, match the plugin release to the application version before installing. At the time of checking, stable AI Diffusion 1.53.0 targets Krita 5, while 1.54.0-pre targets Krita 6. Installing the newest release of each independently can produce an incompatible pair.

---

---

Check the GPU backend before buying more memory

On Windows, check the GPU model and its dedicated GPU memory under Task Manager’s Performance tab. System RAM is a separate resource: a laptop with 16GB RAM does not necessarily have a 16GB graphics card. Apple Silicon uses unified memory, shared between the operating system, applications and graphics work.

For AMD and Intel hardware, verify the exact GPU, operating system and supported backend. ComfyUI supports several GPU families, but its installation requirements vary. InvokeAI currently documents AMD support on Linux and Intel Arc support on Windows and Linux. Having enough VRAM does not guarantee software compatibility.

Memory offloading can let a model run by moving parts between system RAM and VRAM. It can also slow iteration. Start with one image and no upscaler or optional adapters; add those after the basic workflow finishes reliably.

The application, model and workflow are separate choices

• Application: ComfyUI, InvokeAI, or Draw Things supplies the interface and execution tools.
• Model: SD1.5, SDXL or FLUX.2 klein supplies the learned image-generation capability. A checkpoint is a file containing model weights.
• Workflow: the recipe connecting prompts, model loading, sampling and image saving. A ComfyUI JSON file normally does not contain the model itself.
• Add-ons: LoRAs, ControlNets and other adapters add particular styles or controls. They must support the chosen model family.

A recurring beginner problem is importing an impressive workflow before understanding its required models and extensions. Establish one successful local image first. Otherwise, a missing checkpoint, incompatible adapter and failed custom-node installation can all look like the same broken application.

Download size is not a VRAM requirement

The SD1.5 FP16 checkpoint used in our starter test is a single 2.13GB download. Other pipelines split their components across files. For example, ComfyUI’s documented FLUX.2 klein 4B distilled FP8 setup uses:

File	ComfyUI folder	Published size
flux-2-klein-4b-fp8.safetensors	models/diffusion_models/	4.07GB
qwen_3_4b.safetensors	models/text_encoders/	8.04GB
flux2-vae.safetensors	models/vae/	336MB

The sizes listed by Black Forest Labs and Comfy Org add up to about 12.45GB before the application, caches and outputs. The text encoder is larger than the diffusion model in this bundle. Download the selected files rather than every alternative variant in the repository.

Running memory also includes intermediate calculations and image decoding. FP8 or another reduced-precision format can reduce weight storage, but the filename alone doesn’t indicate peak memory. Keep enough disk space for the installation files and the final model collection.

For FLUX.2 klein, retain the matching template’s settings. The distilled 4B model uses a four-step recipe; the base variant is different. Applying the SD1.5 settings below to every model is a common way to get disappointing results.

Starter workflow: one checkpoint, one image, no extensions

This ComfyUI setup keeps the number of dependencies small enough to diagnose. The official ComfyUI first-generation guide includes installation routes, an example workflow, and checkpoint downloads.

1. Install a local ComfyUI instance. The Desktop launcher offers local and Cloud choices. Select local. Use the appropriate Windows, Apple Silicon Mac or Linux installer and its supported backend.
2. Download one checkpoint: v1-5-pruned-emaonly-fp16.safetensors. In Desktop, open the top capsule menu, select Storage and open the configured model directory; use its checkpoints subfolder. Portable and manual installations normally use ComfyUI/models/checkpoints/.
3. Open the basic text-to-image workflow. Select the checkpoint in Load Checkpoint. It provides the model, text encoder and VAE connections needed for this example.
4. Use the settings below. Leave additional LoRAs, ControlNets, refiners and upscalers out of this first run.
5. Generate, inspect and save. Save the workflow JSON alongside the output so you can recover the configuration.

Model: v1-5-pruned-emaonly-fp16.safetensors
Width / height: 512 / 512
Batch size: 1
Steps: 20
CFG: 7
Sampler: euler
Scheduler: normal
Seed: 42, fixed
Denoise: 1.0

Prompt: A realistic photograph of a small red wooden cabin among tall pine trees, distant rugged mountains, clear daylight, detailed timber walls, front three-quarter view, natural colours, architectural photography

Negative prompt: text, watermark, logo, blurry, low quality

A fixed seed makes changes easier to compare within the same configuration. Keep the model, dimensions and sampler unchanged while adjusting one prompt detail. It does not guarantee identical pixels across different hardware or software versions.

What our CPU test measured

On 18 October 2026, we executed ComfyUI 0.41.0 core nodes through a Python runner in an isolated, hosted Linux environment on an AMD EPYC 9V74 CPU. It exposed nine logical CPUs and 9.73 GiB of system memory. PyTorch 2.14.1+cpu used nine threads and FP32 execution, loading the FP16 checkpoint above. The environment blocked network socket calls.

Measurement	Observed result
Checkpoint download	2.13GB; 48.5 seconds on the test connection
Automated package installation	85.3 seconds across the two dependency-install commands, excluding the checkpoint download
Installed source, Python environment and one checkpoint	4.60GB logical file size, excluding temporary downloads and generated outputs
First image, seed 42	154.0 seconds from fresh Python process to saved image, including startup and model preparation
Next image, seed 43	122.4 seconds with the process already running
Reference-image edit after restarting the runner	142.6 seconds including startup; denoise 0.35
Peak process memory	6.21GiB RAM for the text-to-image process; 6.20GiB for the separate editing process. No GPU used.
Offline execution	All three images completed. Socket probes were blocked before and after both processes.

Each setting was run once. These are fresh-process and already-running measurements, with operating-system file caches left in place. Desktop launchers, Windows/Mac installation times and GPU performance were not tested. Package-install timings measure automated commands, excluding operator learning and workflow preparation.

The first output showed a plausible red timber cabin and pine forest, but no visible mountains. At roughly two minutes per subsequent image, this CPU configuration is usable for occasional experiments; it would be frustrating for rapid prompt iteration.

Our DIY AI data hub and image-generation dataset explain our wider image-tool evaluation. The configuration measurements here apply to this specific local workflow.

Use the first image to test what an edit preserves

For a reference-image task, reuse the generated cabin image and change the prompt from a red cabin to a blue cabin. The acceptance condition is specific: change the cabin’s colour while keeping its position, shape and surrounding landscape.

1. Add Load Image and select the original output.
2. Connect its image output to VAE Encode, using the same checkpoint’s VAE.
3. Connect the encoded latent to KSampler in place of Empty Latent Image.
4. Use the blue-cabin prompt, retain 20 steps and start at denoise 0.35.
5. Compare the cabin, roof edges, trees and mountain shapes against the original.

Our result: the colour-change test failed. The reference workflow completed offline and retained the cabin’s position and broad composition, but the cabin stayed red. Contrast and saturation increased, producing harsher detail. Successful execution did not mean the requested edit succeeded.

Whole-image img2img allows the entire scene to change. For precise repair, a masked workflow is better. In InvokeAI, the generation bounding box defines the working area and surrounding context; the inpaint mask selects what to change. Keep useful surroundings inside the box so the model can continue edges and textures. For a simple recolour, a conventional masked colour adjustment may preserve the scene more reliably.

Also, lower denoise does not automatically mean fewer sampling steps in ComfyUI’s standard KSampler. At 20 steps and denoise 0.35, it still performs 20 steps over a narrower noise range. Judge the edit by preservation and measured runtime, rather than assuming it should be much faster.

Your search, your sources

Make DIY AI a preferred source

See more of our reporting in Google Top Stories, AI Overviews and AI Mode.

Add DIY AI on Google

Prove offline operation after a fresh start

A local window can still contain remote processing. ComfyUI has optional Partner Nodes that call paid APIs. InvokeAI can display external API models alongside installed local models, and Draw Things offers optional Cloud compute. Check the selected workflow and compute mode.

1. Finish preparation while online: install the application, model files and dependencies needed by both generation and editing.
2. Save a known configuration and close the application completely.
3. Disconnect external networking: turn off Wi-Fi and disconnect Ethernet or other internet connections. Keep local loopback available for applications that use a browser interface.
4. Start the application again. Generate a new image with a changed seed or prompt, then repeat the reference-image task.
5. Confirm new files were produced. Reopening an old image or reusing a cached unchanged graph does not demonstrate a new offline generation.

Current ComfyUI also documents --offline for manual launches. It disables Partner Nodes and restricts built-in frontend networking. It does not replace an operating-system network block for arbitrary custom-node code.

Passing this check confirms the tested workflow can run without internet access. Recheck after adding a model, extension or remote node. Offline execution also leaves local files to manage: avoid cloud-synchronised input and output folders if those files must remain on the device.

Fix the failed stage before changing the prompt

Symptom	First useful check	Action
No checkpoint in the selector	Is the complete model in this instance’s model directory?	Check the path and download size, then refresh the model list or restart.
Missing or red nodes	Does the workflow require a newer core version or a custom extension?	Return to the basic core-node workflow. Read startup errors before installing more packages.
Out of memory during generation	Dimensions, batch size and additional models	Use batch 1, reduce dimensions and remove optional adapters or upscale passes.
Sampling finishes but image decoding fails	Whether the VAE stage exhausted memory	Try the application’s supported tiled decoding option or a smaller image.
Generation unexpectedly becomes very slow	GPU use, RAM pressure and model offloading	Confirm the intended backend is active and check whether weights are repeatedly moving into system memory.
The workflow asks for credits or fails offline	Remote model selection, missing local files or startup downloads	Replace API steps with local ones and complete required downloads before repeating the cold-start check.

Choose local generation when control earns its upkeep

Local image generation makes sense when you need offline access, want to retain a particular model or repeatedly use a customised workflow. Budget for storage, electricity, hardware wear and maintenance time. A free application doesn’t eliminate those costs, and you still need to check the licence for the exact model and variant.

If you are considering a new GPU, first establish which model and editing task justify it. Readers whose priority is a convenient finished image can use our AI image generator comparison. If local hardware is insufficient and remote processing is acceptable, our GPU hosting for AI guide covers rented infrastructure.

Start with one model and one saved workflow. Choose the setup that produces useful images, supports the edits you need and starts successfully without an internet connection.