# Fooocus: Focused Offline SDXL Image Generation

> Fooocus is an offline Gradio application for generating and editing images with Stable Diffusion XL, aimed at users who want prompt-led workflows without extensive parameter tuning. Its main trade-off is an SDXL-centered design now limited to bug fixes.

**lllyasviel/Fooocus** — Focus on prompting and generating

- Repository: https://github.com/lllyasviel/Fooocus
- Stars: 53,654 · Forks: 8,608
- Language: Python
- License: GPL-3.0
- Published: 2026-10-16 · Updated: 2026-10-16 · Language: en
- Canonical page: https://hysenlabs.com/projects/lllyasviel-fooocus

## Why Fooocus Reduces SDXL Configuration Work

Fooocus targets people who want to concentrate on prompts and reference images rather than assemble a generation graph or tune many sampler settings. It presents Stable Diffusion XL through a Gradio interface and adds an offline GPT-2 based prompt expansion engine. According to the README, prompt processing can improve results for inputs ranging from a short phrase such as "house in garden" to a prompt of roughly 1,000 words.

The project also packages common image operations into a smaller set of user decisions. Text prompts feed generation, while an input image can lead to upscaling, variation, inpainting, outpainting, image-prompt generation, face swapping, or image description. Advanced controls remain available for style, guidance, quality, image number, aspect ratio, negative prompts, sharpness, ControlNet, and other settings. This makes Fooocus a middle ground between a hosted generator with a simplified interface and a lower-level environment that exposes the full pipeline.

Its intended audience is therefore narrow but clear. A user who dislikes prompt engineering may value the expansion engine. A user who already knows how to construct ComfyUI graphs may find Fooocus too opinionated. The project does not attempt to cover every recent image model or workflow. Its design centers on SDXL and Fooocus-specific processing methods, which makes the application easier to approach but also defines its ceiling.

## Inside Fooocus Prompt Expansion and Image Editing

Fooocus separates prompt processing from direct model execution. Its offline GPT-2 based expansion engine receives the entered prompt and prepares an expanded form before generation. Prompt weighting uses A1111-compatible reweighting, including expressions such as `I am (happy:1.5)`, while embedding references use `(embedding:file_name:1.1)`. Multiple prompts are represented by separate lines rather than a special multi-prompt delimiter.

For image-driven work, the interface exposes different operations instead of treating every reference as a generic conditioning input. An input image can be described, used as an image prompt, upscaled at 1.5x or 2x, varied subtly or strongly, or passed through inpainting and outpainting. Directional expansion covers inpainting, up, down, left, and right. Fooocus identifies its own inpainting algorithm and inpainting models as different from the standard SDXL inpainting method.

Face swapping is reached through the image-prompt path and an Advanced control. The README also lists ControlNet under Advanced and describes additional sampler controls such as sampling sharpness. These features indicate a curated workflow rather than a raw model runner. The trade-off is that the application decides how common tasks should be represented. Users who need direct access to every model component or who want to change the pipeline graph may prefer a node-based environment.

## Windows Installation and the First Generated Image

The README provides a packaged Windows route rather than a Python installation tutorial. Download the linked archive from the official Fooocus repository, extract it, and start the application with `run.bat`. The README describes the initial process as requiring fewer than three mouse clicks between downloading the package and generating the first image, although the exact first-run experience depends on package contents, preset choice, and model download state.

After the archive is extracted, this batch file launches Fooocus:

```bash
run.bat
```

On the first launch, Fooocus downloads default models according to the selected preset into `Fooocus\models\checkpoints`. The browser interface then exposes the prompt and image controls. Enter a prompt, choose the relevant operation, and start generation. The README does not document a required command-line prompt syntax, an output directory override for the Windows package, or a complete first-run prompt example. The reliable first-use path is therefore the interface presented after the application starts.

Two additional Windows launchers, `run_anime.bat` and `run_realistic.bat`, select different model presets. These launchers require different models, which Fooocus downloads automatically. Users who need a repeatable setup should record which launcher and preset they use, because the README does not claim that all presets contain the same checkpoints. The default archive link points to v2.5.0 even though the repository lists newer releases, so users should compare the package version before assuming they have the newest release.

## Fooocus Docker Deployment and Persistent Model Paths

The repository includes a Docker configuration for deployments that need the Gradio service exposed on port 7865. The Compose file reserves an NVIDIA GPU, builds from the repository Dockerfile, and stores models, configuration, and related data under a named `fooocus-data` volume. This is a different operational model from the Windows archive.

The service mapping and initial storage settings are declared as follows:

```yaml
services:
  app:
    build: .
    image: ghcr.io/lllyasviel/fooocus
    ports:
     - "7865:7865"
    environment:
      - CMDARGS=--listen
      - DATADIR=/content/data
      - config_path=/content/data/config.txt
```

The Compose file also maps checkpoints, LoRAs, embeddings, VAE approximation models, upscalers, inpainting models, ControlNet models, CLIP vision models, prompt-expansion files, and outputs into `/content/data`. The `path_outputs` setting points to `/content/app/outputs/`, with a warning that outputs outside that directory will not appear in the history log. The named volume preserves data across container replacement, which matters when model files are large or downloads are slow.

The Dockerfile is based on `nvidia/cuda:12.4.1-base-ubuntu22.04`, installs Python dependencies, adds `xformers==0.0.23`, and runs the application through `entrypoint.sh`. The Compose file requests NVIDIA compute capability for device `0`. This is a GPU-oriented deployment. The repository files do not document a CPU-only container configuration, so a machine without a supported Nvidia setup is outside the documented Docker path.

## Where Fooocus Is Constrained by Its LTS Scope

The most important limitation is architectural. The README states that Fooocus is in limited long-term support with bug fixes only, and that existing functionality is considered nearly free of programmatic issues by the project. It explicitly says there are no current plans to migrate to or incorporate newer model architectures. Flux users are directed toward WebUI Forge, ComfyUI, or SwarmUI instead.

That boundary matters when selecting an image-generation application. Fooocus can remain useful for SDXL, but it should not be treated as a path to current model experimentation. New checkpoints may be usable where Fooocus supports SDXL-compatible models, but the README does not claim compatibility with every model format or architecture. The project also does not document a migration mechanism for changing the underlying generation stack.

The application also has a substantial first-run cost. Default checkpoints are downloaded automatically, and the Fooocus inpaint control model is a 1.28GB file downloaded on the first inpainting operation. Users with limited storage or metered connections should account for that before launching the relevant workflow. The README does not document a rollback procedure for an application or model update. An adoption decision should therefore include checking how release archives, configuration files, and model directories are managed locally.

## Fooocus Compared with WebUI Forge and ComfyUI

The README names WebUI Forge and ComfyUI/SwarmUI as alternatives for users interested in newer models such as Flux. The practical difference is workflow structure. Fooocus is built around a focused SDXL experience, with prompt expansion, image prompting, inpainting, variation, upscaling, and face swap presented as accessible operations. Its Advanced controls add more settings without requiring users to assemble a graph.

WebUI Forge, also from the Fooocus author according to the README, is positioned as an alternative platform for newer models. The README recommends ComfyUI/SwarmUI as an alternative platform for exploring newer models, but does not provide a detailed comparison of its workflow structure. The README does not provide installation commands, a complete feature matrix, or a compatibility comparison for those projects. The supported distinction is narrow but important: Fooocus prioritizes a curated SDXL interface, while the named alternatives are suggested for exploring Flux and newer generation methods.

Fooocus is also different from an online service because the project describes it as offline, open source, and non-commercial. That does not remove hardware or licensing obligations. Image generation occurs locally, with models downloaded by the application or supplied in its expected directories. Organizations should check the GPL-3.0 license and their distribution practices before embedding or redistributing the software.

## Fooocus Release History and Maintenance Cost

The repository is not archived, and its last push was on 2025-12-01. That date records repository activity, but it does not imply a feature roadmap. The README explicitly labels Fooocus as limited LTS with bug fixes only. The listed recent releases are v2.5.5 on 2024-08-12, v2.5.4 on 2024-08-11, and v2.5.3 on 2024-08-03. This release sequence is consistent with the README's stated posture: existing behavior receives bug fixes rather than planned integrations for newer model architectures.

The upgrade cost is operational. Users may need to replace or refresh the Windows package, keep model directories consistent, and account for changed preset behavior. The first-use inpaint workflow can also require another large download. The repository includes `update_log.md`, `troubleshoot.md`, and version files, but the README does not document a complete rollback procedure or a formal model migration policy.

Fooocus is licensed under GPL-3.0. The license identifies the project's distribution terms, but it does not by itself answer whether a particular deployment, modification, or distribution arrangement satisfies an organization's obligations. The adoption question is not only whether Fooocus is convenient. It is whether an SDXL-specific application remains useful when the project offers bug fixes only and explicitly has no current plans to adopt newer architectures.

## Conclusion

Fooocus fits users who want an offline, prompt-led SDXL interface with built-in expansion, image prompts, inpainting, upscaling, and face swapping. It does not fit users who need newer architectures such as Flux or expect a node-based generation environment. Before adopting it, verify local GPU memory, obtain the package from the official repository, and confirm that its bug-fix-only support policy matches your long-term needs.

## FAQ

### Does Fooocus work offline?

Yes. The README describes Fooocus as offline software, although the first launch and first inpainting operation can download models from external sources.

### What GPU memory does Fooocus need?

The README states a minimal GPU memory requirement of 4GB for Nvidia. The Docker Compose configuration also requests an NVIDIA GPU with compute capability.

### Can Fooocus generate images with Flux?

The README recommends WebUI Forge or ComfyUI/SwarmUI for Flux and other newer models. It also states that Fooocus has no current plans to migrate to newer architectures.

### How do I start Fooocus on Windows?

Download the archive linked by the official README, extract it, and run `run.bat`. The application downloads default models according to the selected preset on first launch.

### Does Fooocus support image prompts and inpainting?

Yes. The README lists image prompts, inpainting, outpainting, variations, upscaling, face swapping, and image description among the supported workflows.

### What is Fooocus's current support scope?

The repository is not archived, and the last push was on 2025-12-01. However, the README describes Fooocus as limited long-term support with bug fixes only and no current plans to adopt newer model architectures.

## Sources

- [Issues](https://github.com/lllyasviel/Fooocus/issues)
- [License: GPL-3.0](https://github.com/lllyasviel/Fooocus/blob/main/LICENSE)
- [lllyasviel/Fooocus on GitHub](https://github.com/lllyasviel/Fooocus)
- [README](https://github.com/lllyasviel/Fooocus/blob/main/README.md)
- [Releases](https://github.com/lllyasviel/Fooocus/releases)

---

Hysen Labs editorial analysis, written from the project's own repository and release notes. Cite the canonical page: https://hysenlabs.com/projects/lllyasviel-fooocus