How Highres Fix Works in AUTOMATIC1111: Generating High-Resolution Images with Two-Stage Sampling

The Highres Fix is a two-stage diffusion pipeline that generates a low-resolution base image, upscales it, and runs a second img2img pass with configurable denoising strength to produce detailed high-resolution output.

The Highres Fix (abbreviated as HR fix) is a core feature of the AUTOMATIC1111 stable-diffusion-webui designed to overcome the resolution limitations of Stable Diffusion models. According to the source code in modules/processing.py, this feature implements a txt2img first pass followed by an img2img refinement pass controlled by the enable_hr flag, allowing users to generate images at resolutions far exceeding the model's native training dimensions.

What Is Highres Fix in AUTOMATIC1111?

The Highres Fix is a built-in two-stage generation pipeline that solves the architectural limitations of diffusion models trained on fixed resolutions (typically 512×512 or 768×768). Instead of generating a large image in one pass—which often produces repetitive patterns or artifacts—the pipeline separates generation into distinct composition and detail phases.

In modules/ui.py (lines 311-324), the web interface exposes this functionality through the "Hires. fix" accordion, providing controls for upscalers, denoising strength, and optional high-resolution prompts. When enabled via the enable_hr boolean flag, the system automatically executes sample_hr_pass after the initial generation completes.

How Highres Fix Generates High-Resolution Images

The implementation follows a strict three-phase architecture defined in modules/processing.py (lines 1360-1645):

Stage 1: Low-Resolution First Pass

The pipeline begins with standard txt2img sampling. The StableDiffusionProcessingTxt2Img class runs the primary sampler at the user-specified base width and height (typically 512×512).

According to the source code at lines 1360-1365, when self.enable_hr evaluates to true, the system stores the intermediate result in self.firstpass_image and immediately invokes self.sample_hr_pass upon completion of the initial sampling.

Stage 2: Upscaling and Latent Preparation

The sample_hr_pass method handles the transition between resolutions through two distinct upscaling paths:

• Latent upscaling: When self.latent_scale_mode is not None, the system uses torch.nn.functional.interpolate to resize the latent tensors directly (lines 1388-1392).
• Pixel upscaling: For non-latent upscalers like R-ESRGAN, the method decodes low-resolution latents to a PIL image, resizes using images.resize_image, then re-encodes back to latent space (lines 1401-1414).

Before upscaling, if save_images_before_highres_fix is enabled in modules/shared_options.py (lines 53-55), the system calls save_intermediate to write the pre-HR image with the suffix -before-highres-fix (lines 1372-1383).

Stage 3: Second-Pass Diffusion Refinement

The final stage executes an img2img-style diffusion pass over the upscaled latents. The method self.sampler.sample_img2img processes the upscaled tensor using the HR-specific sampler (self.hr_sampler_name), HR scheduler, and optional HR prompt/negative prompt defined in the UI configuration.

The critical parameter denoising_strength (0.0 to 1.0) controls the balance between preservation and regeneration:

• Values near 0.0 preserve the upscaled image with minimal changes
• Values near 1.0 allow the diffusion model to add substantial new detail, potentially altering composition

This second pass occurs at the target resolution (hr_upscale_to_x, hr_upscale_to_y) and concludes with decode_latent_batch converting the final latent batch to the output image (lines 1619-1625).

Configuration Parameters and Options

The Highres Fix exposes several configuration points across the codebase:

• UI Controls: modules/ui.py defines the user-facing parameters including upscaler selection, HR steps, denoising strength, and scale factors (lines 311-324).
• Persistence: modules/shared_options.py contains the global option save_images_before_highres_fix for saving intermediate low-resolution images (lines 53-55).
• Processing: modules/txt2img.py (lines 14-18) wraps the processing class and forwards HR parameters to the pipeline.
• Script Integration: Third-party scripts like scripts/xyz_grid.py check p.enable_hr to adapt behavior when generating comparison grids (lines 657-659).

Practical Implementation Examples

Web UI Configuration

To enable Highres Fix through the graphical interface:

1. Navigate to the Txt2Img tab.
2. Expand the "Hires. fix" accordion.
3. Configure the parameters:
   • Upscaler: Select Latent (nearest-exponential) for fast latent-space upscaling, or R-ESRGAN 4x+ for pixel-space enhancement.
   • Upscale by: Set to 2.0 to double the resolution (e.g., 512×512 → 1024×1024).
   • Denoising strength: Use 0.7 for balanced detail addition without losing composition.
   • Hires steps: Optionally increase from the default (e.g., 20) for additional refinement.
4. Click Generate. The UI executes the two-stage pipeline automatically, displaying only the final high-resolution output.

API Implementation

For programmatic access via the REST API, include HR parameters in your JSON payload:

{
  "prompt": "a majestic castle on a hill, sunrise",
  "negative_prompt": "",
  "steps": 30,
  "width": 512,
  "height": 512,
  "enable_hr": true,
  "denoising_strength": 0.65,
  "hr_scale": 2.0,
  "hr_upscaler": "R-ESRGAN 4x+",
  "hr_second_pass_steps": 20,
  "hr_prompt": "",
  "hr_negative_prompt": ""
}

POST this to http://localhost:7860/sdapi/v1/txt2img. The server processes both passes server-side and returns the final base64-encoded high-resolution image.

Python Scripting

For direct Python invocation within the AUTOMATIC1111 environment:

from modules import txt2img

# Configure processing with Highres Fix enabled

p = txt2img.txt2img_create_processing(
    id_task="1",
    request=None,
    prompt="a cyberpunk city at night, neon lights",
    negative_prompt="low quality, blurry",
    prompt_styles=None,
    n_iter=1,
    batch_size=1,
    cfg_scale=7.0,
    height=512,
    width=512,
    enable_hr=True,               # Enable Highres Fix

    denoising_strength=0.6,
    hr_scale=2.0,
    hr_upscaler="Latent (nearest-exponential)",
    hr_second_pass_steps=15,
    hr_resize_x=0,
    hr_resize_y=0,
    hr_checkpoint_name="Use same checkpoint",
    hr_sampler_name="Use same sampler",
    hr_scheduler="Use same scheduler",
    hr_prompt="",
    hr_negative_prompt="",
    override_settings_texts={}
)

# Execute the full pipeline

images, info, html = txt2img.txt2img(p, None)

This creates a StableDiffusionProcessingTxt2Img instance with enable_hr=True, triggering the sample_hr_pass method after the initial txt2img generation completes.

Summary

• Highres Fix implements a two-stage pipeline (low-res generation → upscale → img2img refinement) to produce images beyond native model resolutions.
• The enable_hr flag in modules/processing.py triggers sample_hr_pass, which handles upscaling via latent interpolation or pixel-space upscalers.
• Denoising strength (0.0-1.0) controls the trade-off between preserving the first-pass composition and adding high-frequency detail in the second pass.
• Configuration spans modules/ui.py (interface), modules/shared_options.py (persistence options), and modules/txt2img.py (API wrapper).
• Both the Web UI and REST API support full programmatic control over HR parameters including separate prompts for the second pass.

Frequently Asked Questions

What is the difference between using Highres Fix versus generating at high resolution directly?

Generating directly at high resolution (e.g., 1024×1024 in a 512-trained model) often produces repetitive patterns or anatomical errors because the model's attention mechanisms degrade at non-native resolutions. Highres Fix first establishes composition at the model's native resolution, then uses the second pass to intelligently add detail while maintaining structural coherence, resulting in cleaner high-resolution outputs.

How does the denoising strength parameter affect the final image in Highres Fix?

The denoising_strength parameter (specified in modules/processing.py lines 1450-1460) determines how much the second diffusion pass deviates from the upscaled first-pass image. Values below 0.4 preserve most of the original content with minor smoothing, while values above 0.7 allow significant detail generation that may alter fine textures or facial features. Most workflows use 0.5-0.75 for optimal results.

Can I use a different prompt for the Highres Fix second pass?

Yes. The UI configuration in modules/ui.py exposes optional hr_prompt and hr_negative_prompt fields. When provided, these override the original prompts during the second img2img pass in sample_hr_pass, allowing you to adjust style or emphasis specifically for the high-resolution refinement stage without regenerating the base composition.

Why does the first-pass image sometimes get saved with a "-before-highres-fix" suffix?

When the global option save_images_before_highres_fix is enabled in modules/shared_options.py (default False), the pipeline calls save_intermediate during sample_hr_pass (lines 1372-1383) to persist the low-resolution image before upscaling occurs. This allows comparison between the base generation and the final refined output, useful for debugging prompt adherence versus detail quality.

{
  "mcpServers": {
    "instagit": {
      "command": "npx",
      "args": ["-y", "instagit@latest"]
    }
  }
}