fastsdcpu

The name is a little bit of a lie. fastsdcpu does not run Stable Diffusion on your CPU inside ComfyUI - it's a client that talks to a separate FastSDCPU server over HTTP. Wire it up, give it a prompt, and it fires a request at the server and hands back whatever image it gets. Think of it as a remote control for a machine that isn't necessarily the one running ComfyUI.

That server is where the actual generation happens. FastSDCPU is a self-hosted webserver built by Rupesh Sreeramanan (rupeshs, simpleuserhere on Reddit) that serves distilled SD 1.5/SDXL models with a heavy focus on Intel CPUs and iGPUs via OpenVINO. People genuinely run it on boxes a GPU generation never sees - the thread that announced this extension mentions a Raspberry Pi 4, and users generate on 7th-gen Intel NUCs. If your only machine has no meaningful GPU, this is a path that works. If you do have a decent GPU, you don't want it - plain ComfyUI with an LCM or Turbo checkpoint is simpler and better.

How it works

The node builds a JSON request mirroring the FastSDCPU API and POSTs it to /api/generate on your endpoint (default http://localhost:8000). Your prompt and negative_prompt go in as-is; width/height become image_width/image_height; steps becomes inference_steps; cfg becomes guidance_scale. clip_skip and token_merging pass through; batch_size becomes number_of_images, and batch_count repeats the request that many times, bumping the seed each pass.

Two optional inputs change what's sent. Wire an IMAGE into image and the node base64-JPEGs it and switches the task to image_to_image, with i2i_strength (default 0.75) controlling how far it strays. Set openvino_model and it requests an OpenVINO model; otherwise it sends lcm_model. The response is base64 images plus a latency figure; the node decodes them into an IMAGE tensor and returns the latency as a STRING.

The inputs that matter

Most required fields are normal generation knobs; here's what to actually touch:

• steps and cfg - defaults 1 and 1, and not arbitrary. Every model these pickers feed is distilled (LCM, Turbo, Lightning, Hyper-SD), with the guidance baked in: CFG above ~2 overcooks, and steps should match the model. LCM wants 4–8 steps at CFG 1–2; Lightning wants its exact step count at CFG ~0. Oversaturated or grey output means your CFG is too high or your steps are wrong.
• use_taesd (on by default) - swaps the full VAE for a tiny autoencoder. Faster decode, marginally rougher detail. Leave it on; that's the whole point of this stack.
• use_local_path + endpoint - use_local_path tells the server to treat the model string as a folder path instead of a HuggingFace ID (pairs with fastsdcpu_loadModel). endpoint is only worth changing when your server runs on another machine.
• seed and use_seed - use_seed defaults to off; flip it on for reproducible images from ComfyUI's seed.

The two outputs are Image (wire it into Save Image / preview) and Latency, a string you can display for per-image render time.

Installing it

The pack itself is tiny - its requirements.txt is just requests, pillow, numpy, torch, because it's a client. Install it the usual way:

• ComfyUI Manager: search "ComfyUI-FastSDCPU" and install, then restart.
• Manually: cd ComfyUI/custom_nodes && git clone https://github.com/BetaDoggo/ComfyUI-FastSDCPU and restart.

Then comes the part everyone forgets: install the server. Clone rupeshs/fastsdcpu, run its install.bat/install.sh, optionally set DEVICE=GPU for an Intel iGPU, and start it with start-webserver.bat/start-webserver.sh. It listens on port 8000, matching the node's default endpoint; first generation downloads the model from HuggingFace, so expect a few GB.

Common issues

• Connection refused / nothing happens. The node is a client; if the FastSDCPU server isn't running, this is just a pretty error message. Start the server and check port 8000 isn't taken.
• OpenVINO models eat RAM. The README warns they need significantly more memory than standard models. "Fast" doesn't mean small.
• Regular (non-LCM) models are slow. FastSDCPU is optimised around LCM-style models; plain checkpoints get inefficient sampling parameters and need more steps than they should. Stick to the distilled models in the picker nodes.
• Custom models don't show up. They live in ComfyUI/models/diffusers, and local model selection only works when the server runs on the same machine as ComfyUI. Remote server? You'll be typing server-side paths yourself.

Honest verdict: this node earns its keep exactly when your hardware can't do anything else. For everyone else it's a fiddly extra server babysitting images a regular GPU workflow makes faster.