code

app.py

@@ -0,0 +1,542 @@
+#!/usr/bin/env python3
+"""
+SDXL Model Merger - Modernized with modular architecture and improved UI/UX.
+
+This application allows you to:
+- Load SDXL checkpoints with optional VAE and multiple LoRAs
+- Generate images with seamless tiling support
+- Export merged models with quantization options
+
+Author: Qwen Code Assistant
+"""
+
+import gradio as gr
+
+
+def create_app():
+    """Create and configure the Gradio app."""
+
+    header_css = """
+    .header-gradient {
+        background: linear-gradient(135deg, #10b981 0%, #7c3aed 100%);
+        -webkit-background-clip: text;
+        -webkit-text-fill-color: transparent;
+        background-clip: text;
+    }
+
+    .feature-card {
+        border-radius: 12px;
+        padding: 20px;
+        margin-bottom: 16px;
+        box-shadow: 0 4px 6px -1px rgba(0, 0, 0, 0.1);
+        transition: transform 0.2s ease;
+    }
+
+    .feature-card:hover {
+        transform: translateY(-2px);
+        box-shadow: 0 10px 15px -3px rgba(0, 0, 0, 0.1);
+    }
+
+    .gradio-container .label {
+        font-weight: 600;
+        color: #374151;
+        margin-bottom: 8px;
+    }
+
+    .status-success { color: #059669 !important; font-weight: 600; }
+    .status-error { color: #dc2626 !important; font-weight: 600; }
+    .status-warning { color: #d97706 !important; font-weight: 600; }
+
+    .gradio-container .btn {
+        border-radius: 8px;
+        padding: 12px 24px;
+        font-weight: 600;
+    }
+
+    .gradio-container textarea,
+    .gradio-container input[type="number"],
+    .gradio-container input[type="text"] {
+        border-radius: 8px;
+        border-color: #d1d5db;
+    }
+
+    .gradio-container textarea:focus,
+    .gradio-container input:focus {
+        outline: none;
+        border-color: #6366f1;
+        box-shadow: 0 0 0 3px rgba(99, 102, 241, 0.1);
+    }
+
+    .gradio-container .tabitem {
+        background: transparent;
+        border-radius: 12px;
+    }
+
+    .progress-text {
+        font-weight: 500;
+        color: #6b7280 !important;
+    }
+    """
+
+    from src.pipeline import load_pipeline, cancel_download
+    from src.generator import generate_image
+    from src.exporter import export_merged_model
+    from src.config import get_cached_models, get_cached_checkpoints, get_cached_vaes, get_cached_loras
+
+    with gr.Blocks(title="SDXL Model Merger", css=header_css) as demo:
+        # Header section
+        with gr.Column(elem_classes=["feature-card"]):
+            gr.HTML("""
+                <div style="text-align: center; margin-bottom: 24px;">
+                    <h1 style="font-size: 2.5em; margin: 0; line-height: 1.2;">
+                        <span class="header-gradient">SDXL Model Merger</span>
+                    </h1>
+                    <p style="color: #6b7280; font-size: 1.1em; max-width: 600px; margin: 16px auto;">
+                        Merge checkpoints, LoRAs, and VAEs - then bake LoRAs into a single exportable
+                        checkpoint with optional quantization.
+                    </p>
+                </div>
+            """)
+
+            # Feature highlights
+            with gr.Row():
+                with gr.Column(scale=1):
+                    gr.HTML("""
+                        <div style="text-align: center; padding: 16px;">
+                            <div style="font-size: 2.5em; margin-bottom: 8px;">🚀</div>
+                            <strong>Fast Loading</strong>
+                            <p style="font-size: 0.85em; color: #6b7280; margin-top: 4px;">With progress tracking & cache</p>
+                        </div>
+                    """)
+                with gr.Column(scale=1):
+                    gr.HTML("""
+                        <div style="text-align: center; padding: 16px;">
+                            <div style="font-size: 2.5em; margin-bottom: 8px;">🎨</div>
+                            <strong>Panorama Gen</strong>
+                            <p style="font-size: 0.85em; color: #6b7280; margin-top: 4px;">Seamless tiling support</p>
+                        </div>
+                    """)
+                with gr.Column(scale=1):
+                    gr.HTML("""
+                        <div style="text-align: center; padding: 16px;">
+                            <div style="font-size: 2.5em; margin-bottom: 8px;">📦</div>
+                            <strong>Export Ready</strong>
+                            <p style="font-size: 0.85em; color: #6b7280; margin-top: 4px;">Quantization & format options</p>
+                        </div>
+                    """)
+
+        gr.Markdown("---")
+
+        with gr.Tab("Load Pipeline"):
+            gr.Markdown("### Load SDXL Pipeline with Checkpoint, VAE, and LoRAs")
+
+            # Progress indicator for pipeline loading
+            load_progress = gr.Textbox(
+                label="Loading Progress",
+                placeholder="Ready to start...",
+                show_label=True,
+                info="Real-time status of model downloads and pipeline setup"
+            )
+
+            with gr.Row():
+                with gr.Column(scale=2):
+                    # Checkpoint URL with cached models dropdown
+                    checkpoint_url = gr.Textbox(
+                        label="Base Model (.safetensors) URL",
+                        value="https://civitai.com/api/download/models/354657?type=Model&format=SafeTensor&size=full&fp=fp16",
+                        placeholder="e.g., https://civitai.com/api/download/models/...",
+                        info="Download link for the base SDXL checkpoint"
+                    )
+
+                    # Dropdown of cached checkpoints
+                    cached_checkpoints = gr.Dropdown(
+                        choices=["(None found)"] + get_cached_checkpoints(),
+                        label="Cached Checkpoints",
+                        value="(None found)" if not get_cached_checkpoints() else None,
+                        info="Models already downloaded to .cache/"
+                    )
+
+                    # VAE URL
+                    vae_url = gr.Textbox(
+                        label="VAE (.safetensors) URL",
+                        value="https://huggingface.co/madebyollin/sdxl-vae-fp16-fix/resolve/main/sdxl.vae.safetensors?download=true",
+                        placeholder="Leave blank to use model's built-in VAE",
+                        info="Optional custom VAE for improved quality"
+                    )
+
+                    # Dropdown of cached VAEs
+                    cached_vaes = gr.Dropdown(
+                        choices=["(None found)"] + get_cached_vaes(),
+                        label="Cached VAEs",
+                        value="(None found)" if not get_cached_vaes() else None,
+                        info="Select a VAE to load"
+                    )
+
+                with gr.Column(scale=1):
+                    # LoRA URLs input
+                    lora_urls = gr.Textbox(
+                        label="LoRA URLs (one per line)",
+                        lines=5,
+                        value="https://civitai.com/api/download/models/143197?type=Model&format=SafeTensor",
+                        placeholder="https://civit.ai/...\nhttps://huggingface.co/...",
+                        info="Multiple LoRAs can be loaded and fused together"
+                    )
+
+                    # Dropdown of cached LoRAs
+                    cached_loras = gr.Dropdown(
+                        choices=["(None found)"] + get_cached_loras(),
+                        label="Cached LoRAs",
+                        value="(None found)" if not get_cached_loras() else None,
+                        info="Select a LoRA to add to the list below"
+                    )
+
+                    lora_strengths = gr.Textbox(
+                        label="LoRA Strengths",
+                        value="1.0",
+                        placeholder="e.g., 0.8,1.0,0.5",
+                        info="Comma-separated strength values for each LoRA"
+                    )
+
+            with gr.Row():
+                load_btn = gr.Button("🚀 Load Pipeline", variant="primary", size="lg")
+
+            # Detailed status display
+            load_status = gr.HTML(
+                label="Status",
+                value='<div class="status-success">✅ Ready to load pipeline</div>',
+            )
+
+        with gr.Tab("Generate Image"):
+            gr.Markdown("### Generate Panorama Images with Seamless Tiling")
+
+            # Progress indicator for image generation
+            gen_progress = gr.Textbox(
+                label="Generation Progress",
+                placeholder="Ready to generate...",
+                show_label=True,
+                info="Real-time status of image generation"
+            )
+
+            with gr.Row():
+                with gr.Column(scale=1):
+                    prompt = gr.Textbox(
+                        label="Positive Prompt",
+                        value="Glowing mushrooms around pyramids amidst a cosmic backdrop, equirectangular, 360 panorama, cinematic",
+                        lines=4,
+                        placeholder="Describe the image you want to generate..."
+                    )
+
+                    cfg = gr.Slider(
+                        minimum=1.0, maximum=20.0, value=7.5, step=0.5,
+                        label="CFG Scale",
+                        info="Higher values make outputs match prompt more strictly"
+                    )
+
+                    height = gr.Number(
+                        value=1024, precision=0,
+                        label="Height (pixels)",
+                        info="Output image height"
+                    )
+
+                with gr.Column(scale=1):
+                    negative_prompt = gr.Textbox(
+                        label="Negative Prompt",
+                        value="boring, text, signature, watermark, low quality, bad quality",
+                        lines=4,
+                        placeholder="Elements to avoid in generation..."
+                    )
+
+                    steps = gr.Slider(
+                        minimum=1, maximum=100, value=25, step=1,
+                        label="Inference Steps",
+                        info="More steps = better quality but slower"
+                    )
+
+                    width = gr.Number(
+                        value=2048, precision=0,
+                        label="Width (pixels)",
+                        info="Output image width"
+                    )
+
+            with gr.Row():
+                tile_x = gr.Checkbox(True, label="X-axis Seamless Tiling")
+                tile_y = gr.Checkbox(False, label="Y-axis Seamless Tiling")
+
+            with gr.Row():
+                gen_btn = gr.Button("✨ Generate Image", variant="secondary", size="lg")
+
+            with gr.Row():
+                image_output = gr.Image(
+                    label="Result",
+                    height=400,
+                    show_label=True
+                )
+                with gr.Column():
+                    gen_status = gr.HTML(
+                        label="Generation Status",
+                        value='<div class="status-success">✅ Ready to generate</div>',
+                    )
+
+                    gr.HTML("""
+                        <div style="margin-top: 16px; padding: 12px; background-color: #e5e7eb !important; border-radius: 8px;">
+                            <strong style="color: #1f2937 !important;">💡 Tips:</strong>
+                            <ul style="margin: 8px 0; padding-left: 20px; font-size: 0.9em; color: #1f2937 !important;">
+                                <li>Use wide aspect ratios (e.g., 1024x2048) for panoramas</li>
+                                <li>Enable seamless tiling for texture-like outputs</li>
+                                <li>Lower CFG (3-5) for more creative results</li>
+                            </ul>
+                        </div>
+                    """)
+
+        with gr.Tab("Export Model"):
+            gr.Markdown("### Export Merged Checkpoint with Quantization Options")
+
+            # Progress indicator for export
+            export_progress = gr.Textbox(
+                label="Export Progress",
+                placeholder="Ready to export...",
+                show_label=True,
+                info="Real-time status of model export and quantization"
+            )
+
+            with gr.Row():
+                include_lora = gr.Checkbox(
+                    True,
+                    label="Include Fused LoRAs",
+                    info="Bake the loaded LoRAs into the exported model"
+                )
+
+                quantize_toggle = gr.Checkbox(
+                    False,
+                    label="Apply Quantization",
+                    info="Reduce model size with quantization"
+                )
+
+            qtype_row = gr.Row(visible=True)
+            with qtype_row:
+                qtype_dropdown = gr.Dropdown(
+                    choices=["none", "int8", "int4", "float8"],
+                    value="int8",
+                    label="Quantization Method",
+                    info="Trade quality for smaller file size"
+                )
+
+            with gr.Row():
+                format_dropdown = gr.Dropdown(
+                    choices=["safetensors", "bin"],
+                    value="safetensors",
+                    label="Export Format",
+                    info="safetensors is recommended for safety"
+                )
+
+            with gr.Row():
+                export_btn = gr.Button("💾 Save Merged Checkpoint", variant="primary", size="lg")
+
+            with gr.Row():
+                download_link = gr.File(
+                    label="Download Merged File",
+                    show_label=True,
+                )
+
+                with gr.Column():
+                    export_status = gr.HTML(
+                        label="Export Status",
+                        value='<div class="status-success">✅ Ready to export</div>',
+                    )
+
+                    gr.HTML("""
+                        <div style="margin-top: 16px; padding: 12px; background: #e0f2fe; border-radius: 8px;">
+                            <strong>ℹ️ About Quantization:</strong>
+                            <p style="font-size: 0.9em; margin: 8px 0;">
+                                Reduces model size by lowering precision. Int8 is typically
+                                lossless for inference while cutting size in half.
+                            </p>
+                        </div>
+                    """)
+
+        # Event handlers - all inside Blocks context
+
+        def on_load_pipeline_start():
+            """Called when pipeline loading starts."""
+            return (
+                '<div class="status-warning">⏳ Loading started...</div>',
+                "Starting download...",
+                gr.update(interactive=False)
+            )
+
+        def on_load_pipeline_complete(status_msg, progress_text):
+            """Called when pipeline loading completes."""
+            if "✅" in status_msg:
+                return (
+                    '<div class="status-success">✅ Pipeline loaded successfully!</div>',
+                    progress_text,
+                    gr.update(interactive=True)
+                )
+            elif "⚠️" in status_msg:
+                return (
+                    '<div class="status-warning">⚠️ Download cancelled</div>',
+                    progress_text,
+                    gr.update(interactive=True)
+                )
+            else:
+                return (
+                    f'<div class="status-error">{status_msg}</div>',
+                    progress_text,
+                    gr.update(interactive=True)
+                )
+
+        load_btn.click(
+            fn=on_load_pipeline_start,
+            inputs=[],
+            outputs=[load_status, load_progress, load_btn],
+        ).then(
+            fn=load_pipeline,
+            inputs=[checkpoint_url, vae_url, lora_urls, lora_strengths],
+            outputs=[load_status, load_progress],
+            show_api=False,
+        )
+
+        def on_cached_checkpoint_change(cached_path):
+            """Update URL when a cached checkpoint is selected."""
+            if cached_path and cached_path != "(None found)":
+                return gr.update(value=f"file://{cached_path}")
+            return gr.update()
+
+        cached_checkpoints.change(
+            fn=lambda x: gr.update(value=f"file://{x}" if x and x != "(None found)" else ""),
+            inputs=cached_checkpoints,
+            outputs=checkpoint_url,
+        )
+
+        def on_cached_vae_change(cached_path):
+            """Update VAE URL when a cached VAE is selected."""
+            if cached_path and cached_path != "(None found)":
+                return gr.update(value=f"file://{cached_path}")
+            return gr.update()
+
+        cached_vaes.change(
+            fn=on_cached_vae_change,
+            inputs=cached_vaes,
+            outputs=vae_url,
+        )
+
+        def on_cached_lora_change(cached_path, current_urls):
+            """Add cached LoRA to the list."""
+            if cached_path and cached_path != "(None found)":
+                # Add new LoRA to existing URLs (avoid duplicate)
+                urls_list = [u.strip() for u in current_urls.split("\n") if u.strip()]
+                if cached_path not in urls_list:
+                    urls_list.append(cached_path)
+                    return gr.update(value="\n".join(urls_list))
+            return gr.update()
+
+        cached_loras.change(
+            fn=on_cached_lora_change,
+            inputs=[cached_loras, lora_urls],
+            outputs=lora_urls,
+        )
+
+
+        def on_generate_start():
+            """Called when image generation starts."""
+            return (
+                '<div class="status-warning">⏳ Generating image...</div>',
+                "Starting generation...",
+                gr.update(interactive=False)
+            )
+
+        def on_generate_complete(status_msg, progress_text, image):
+            """Called when image generation completes."""
+            if image is None:
+                return (
+                    f'<div class="status-error">{status_msg}</div>',
+                    "",
+                    gr.update(interactive=True),
+                    gr.update()
+                )
+            else:
+                return (
+                    '<div class="status-success">✅ Generation complete!</div>',
+                    "Done",
+                    gr.update(interactive=True),
+                    gr.update(value=image)
+                )
+
+        gen_btn.click(
+            fn=on_generate_start,
+            inputs=[],
+            outputs=[gen_status, gen_progress, gen_btn],
+        ).then(
+            fn=generate_image,
+            inputs=[prompt, negative_prompt, cfg, steps, height, width, tile_x, tile_y],
+            outputs=[image_output, gen_progress],
+            show_api=False,
+        ).then(
+            fn=lambda img, msg: on_generate_complete(msg, "Done", img),
+            inputs=[image_output, gen_progress],
+            outputs=[gen_status, gen_progress, gen_btn, image_output],
+        )
+
+        def on_export_start():
+            """Called when export starts."""
+            return (
+                '<div class="status-warning">⏳ Export started...</div>',
+                "Starting export...",
+                gr.update(interactive=False)
+            )
+
+        def on_export_complete(status_msg, progress_text, file_path):
+            """Called when export completes."""
+            if file_path is None:
+                return (
+                    f'<div class="status-error">{status_msg}</div>',
+                    "",
+                    gr.update(interactive=True),
+                    gr.update(value=None)
+                )
+            else:
+                return (
+                    '<div class="status-success">✅ Export complete!</div>',
+                    "Exported successfully",
+                    gr.update(interactive=True),
+                    gr.update(value=file_path)
+                )
+
+        export_btn.click(
+            fn=on_export_start,
+            inputs=[],
+            outputs=[export_status, export_progress, export_btn],
+        ).then(
+            fn=lambda inc, q, qt, fmt: export_merged_model(
+                include_lora=inc,
+                quantize=q and (qt != "none"),
+                qtype=qt if qt != "none" else None,
+                save_format=fmt,
+            ),
+            inputs=[include_lora, quantize_toggle, qtype_dropdown, format_dropdown],
+            outputs=[download_link, export_progress],
+            show_api=False,
+        ).then(
+            fn=lambda path, msg: on_export_complete(msg, "Exported", path),
+            inputs=[download_link, export_progress],
+            outputs=[export_status, export_progress, export_btn, download_link],
+        )
+
+        quantize_toggle.change(
+            fn=lambda checked: gr.update(visible=checked),
+            inputs=[quantize_toggle],
+            outputs=qtype_row,
+        )
+
+    return demo
+
+
+def main():
+    """Create and launch the Gradio app."""
+    app = create_app()
+    # CSS is embedded in the Blocks, so we pass it to launch for Gradio 6+
+    app.launch()
+
+
+if __name__ == "__main__":
+    main()

requirements.txt

@@ -0,0 +1,20 @@
+# SDXL Model Merger - Dependencies
+
+# Core ML frameworks
+torch>=2.0.0
+diffusers>=0.24.0
+transformers>=4.35.0
+safetensors>=0.4.0
+
+# Image processing
+Pillow>=10.0.0
+
+# UI framework
+gradio>=4.0.0
+
+# Download utilities
+tqdm>=4.65.0
+requests>=2.31.0
+
+# Optional: quantization support
+optimum-quanto>=0.2.0

src/__init__.py

@@ -0,0 +1,3 @@
+"""SDXL Model Merger - Modular SDXL pipeline management and generation."""
+
+__version__ = "1.0.0"

src/config.py

@@ -0,0 +1,129 @@
+"""Configuration constants and global settings for SDXL Model Merger."""
+
+import os
+from pathlib import Path
+
+# ──────────────────────────────────────────────
+# Paths & Directories
+# ──────────────────────────────────────────────
+SCRIPT_DIR = Path.cwd()
+CACHE_DIR = SCRIPT_DIR / ".cache"
+CACHE_DIR.mkdir(exist_ok=True)
+
+# ──────────────────────────────────────────────
+# Default URLs
+# ──────────────────────────────────────────────
+DEFAULT_CHECKPOINT_URL = "https://civitai.com/api/download/models/354657?type=Model&format=SafeTensor&size=full&fp=fp16"
+DEFAULT_VAE_URL        = "https://huggingface.co/madebyollin/sdxl-vae-fp16-fix/resolve/main/sdxl.vae.safetensors?download=true"
+DEFAULT_LORA_URLS      = "https://civitai.com/api/download/models/143197?type=Model&format=SafeTensor"
+
+# ──────────────────────────────────────────────
+# PyTorch & Device Settings
+# ──────────────────────────────────────────────
+import torch
+
+
+def get_device_info() -> tuple[str, str]:
+    """
+    Detect and return the optimal device for ML inference.
+    
+    Returns:
+        Tuple of (device_name, device_description)
+    """
+    if torch.cuda.is_available():
+        device_name = "cuda"
+        device_desc = f"CUDA (GPU: {torch.cuda.get_device_name(0)})"
+    elif torch.backends.mps.is_available():
+        device_name = "mps"
+        device_desc = "Apple Silicon MPS"
+    else:
+        device_name = "cpu"
+        device_desc = "CPU (no GPU available)"
+    
+    return device_name, device_desc
+
+
+device, device_description = get_device_info()
+dtype = torch.float16
+
+print(f"🚀 Using device: {device_description}")
+
+# ──────────────────────────────────────────────
+# Global State
+# ──────────────────────────────────────────────
+pipe = None
+download_cancelled = False
+
+# ──────────────────────────────────────────────
+# Generation Defaults
+# ──────────────────────────────────────────────
+DEFAULT_PROMPT = "Glowing mushrooms around pyramids amidst a cosmic backdrop, equirectangular, 360 panorama, cinematic"
+DEFAULT_NEGATIVE_PROMPT = "boring, text, signature, watermark, low quality, bad quality"
+
+# ──────────────────────────────────────────────
+# Model Presets (URLs for common models)
+# ──────────────────────────────────────────────
+MODEL_PRESETS = {
+    # Checkpoints
+    "DreamShaper XL v2": "https://civitai.com/api/download/models/354657?type=Model&format=SafeTensor&size=full&fp=fp16",
+    "Realism Engine SDXL": "https://civitai.com/api/download/models/328799?type=Model&format=SafeTensor&size=full&fp=fp16",
+    "Juggernaut XL v9": "https://civitai.com/api/download/models/350565?type=Model&format=SafeTensor&size=full&fp=fp16",
+    
+    # VAEs
+    "VAE-FP16 Fix": "https://huggingface.co/madebyollin/sdxl-vae-fp16-fix/resolve/main/sdxl.vae.safetensors?download=true",
+    
+    # LoRAs
+    "Rainbow Color LoRA": "https://civitai.com/api/download/models/127983?type=Model&format=SafeTensor",
+    "More Details LoRA": "https://civitai.com/api/download/models/280590?type=Model&format=SafeTensor",
+    "Epic Realism LoRA": "https://civitai.com/api/download/models/346631?type=Model&format=SafeTensor",
+}
+
+
+def get_cached_models():
+    """Get list of cached model files."""
+    if not CACHE_DIR.exists():
+        return []
+    
+    models = []
+    for file in sorted(CACHE_DIR.glob("*.safetensors")):
+        models.append(str(file))
+    return models
+
+
+def get_cached_model_names():
+    """Get display names for cached models."""
+    models = get_cached_models()
+    return [str(m.name) for m in models]
+
+
+def get_cached_checkpoints():
+    """Get list of cached checkpoint files (model_id_model.safetensors)."""
+    if not CACHE_DIR.exists():
+        return []
+
+    models = []
+    for file in sorted(CACHE_DIR.glob("*_model.safetensors")):
+        models.append(str(file))
+    return models
+
+
+def get_cached_vaes():
+    """Get list of cached VAE files (model_id_*_vae.safetensors)."""
+    if not CACHE_DIR.exists():
+        return []
+
+    models = []
+    for file in sorted(CACHE_DIR.glob("*_vae.safetensors")):
+        models.append(str(file))
+    return models
+
+
+def get_cached_loras():
+    """Get list of cached LoRA files (model_id_*_lora.safetensors)."""
+    if not CACHE_DIR.exists():
+        return []
+
+    models = []
+    for file in sorted(CACHE_DIR.glob("*_lora.safetensors")):
+        models.append(str(file))
+    return models

src/downloader.py

@@ -0,0 +1,248 @@
+"""Download utilities for SDXL Model Merger with Gradio progress integration."""
+
+import re
+import requests
+from pathlib import Path
+from tqdm import tqdm as TqdmBase
+
+from .config import download_cancelled
+
+
+def extract_model_id(url: str) -> str | None:
+    """Extract CivitAI model ID from URL."""
+    match = re.search(r'/models/(\d+)', url)
+    return match.group(1) if match else None
+
+
+def get_safe_filename_from_url(
+    url: str,
+    default_name: str = "model.safetensors",
+    suffix: str = "",
+    type_prefix: str | None = None
+) -> str:
+    """
+    Generate a safe filename with model ID from URL.
+
+    For CivitAI URLs like https://civitai.com/api/download/models/12345?type=...
+
+    Naming patterns:
+    - Checkpoint (type_prefix='model'): 12345_model.safetensors or 12345_model_anime_style.safetensors
+    - VAE (suffix='_vae'): 12345_vae.safetensors or 12345_anime_vae.safetensors
+    - LoRA (suffix='_lora'): 12345_lora.safetensors or 12345_name_lora.safetensors
+
+    For HuggingFace URLs without model IDs, attempts to extract name from path or uses suffix-based naming.
+
+    Args:
+        url: The download URL
+        default_name: Fallback filename if extraction fails
+        suffix: Optional suffix to append before .safetensors (e.g., '_vae', '_lora')
+        type_prefix: Optional prefix after model_id (e.g., 'model' -> 12345_model.safetensors)
+    """
+    model_id = extract_model_id(url)
+    
+    # If no CivitAI model ID, try to generate a name from HuggingFace path
+    if not model_id and "huggingface.co" in url:
+        # Try to extract name from URL path (e.g., sdxl-vae-fp16-fix -> vae)
+        try:
+            parts = url.split("huggingface.co/")[1] if "huggingface.co/" in url else ""
+            if parts:
+                # Get the repo name (second part after org/)
+                path_parts = [p for p in parts.split("/") if p]
+                if len(path_parts) >= 2:
+                    repo_name = path_parts[1]
+                    # Clean up and create a simple identifier
+                    clean_repo = re.sub(r'[^a-zA-Z0-9]', '_', repo_name)[:30].strip('_')
+                    if clean_repo:
+                        model_id = f"hf_{clean_repo}"
+        except Exception:
+            pass
+    
+    if not model_id:
+        return default_name
+
+    # Build the name portion: either clean name from URL or fallback
+    name_part = ""
+    
+    # For VAE/LoRA types, prefer the suffix-based naming and skip Content-Disposition parsing
+    # to avoid double naming (e.g., sdxlvae_vae instead of just vae)
+    is_special_type = suffix in ("_vae", "_lora")
+    
+    if not is_special_type:
+        try:
+            response = requests.head(url, timeout=10, allow_redirects=True)
+            cd = response.headers.get('Content-Disposition', '')
+            match = re.search(r'filename="([^"]+)"', cd)
+            if match:
+                filename = match.group(1)
+                # Extract base name without extension
+                base_name = Path(filename).stem
+                # Clean up the name (remove special chars)
+                clean_name = re.sub(r'[^\w\s-]', '', base_name)[:50]
+                clean_name = re.sub(r'[-\s]+', '_', clean_name.strip('-_'))
+                if clean_name:
+                    name_part = clean_name
+        except Exception:
+            pass
+
+    # Build filename with model_id, optional type_prefix, optional name_part, and suffix
+    parts = [model_id]
+    if type_prefix:
+        parts.append(type_prefix)
+    if name_part:
+        parts.append(name_part)
+    if suffix:
+        # Avoid double underscores: only add separator if needed
+        if not suffix.startswith('_'):
+            parts.append('_' + suffix.lstrip('_'))
+        else:
+            parts.append(suffix)
+
+    return '_'.join(p for p in parts if p).replace('__', '_') + '.safetensors'
+
+
+class TqdmGradio(TqdmBase):
+    """tqdm subclass that sends progress updates to Gradio's gr.Progress()"""
+    
+    def __init__(self, *args, gradio_prog=None, **kwargs):
+        super().__init__(*args, **kwargs)
+        self.gradio_prog = gradio_prog
+        self.last_pct = 0
+
+    def update(self, n=1):
+        global download_cancelled
+        if download_cancelled:
+            raise KeyboardInterrupt("Download cancelled by user")
+        super().update(n)
+        if self.gradio_prog and self.total:
+            pct = int(100 * self.n / self.total)
+            # Only update UI every ~5% to avoid spamming
+            if pct != self.last_pct and pct % 5 == 0:
+                self.last_pct = pct
+                self.gradio_prog(pct / 100)
+
+
+def set_download_cancelled(value: bool):
+    """Set the global download cancellation flag."""
+    global download_cancelled
+    download_cancelled = value
+
+
+def get_cached_file_size(url: str) -> tuple[Path | None, int | None]:
+    """
+    Check if file exists in cache and matches expected size.
+    Returns (path, expected_size) or (None, None) if no valid cache.
+    """
+    # Simple implementation - would need URL-to-filename mapping for production
+    return None, None
+
+
+def download_file_with_progress(url: str, output_path: Path, progress_bar=None) -> Path:
+    """
+    Download a file with Gradio-synced progress bar + cancel support.
+
+    Args:
+        url: File URL to download (http/https/file)
+        output_path: Destination path for downloaded file
+        progress_bar: Optional gr.Progress() object for UI updates
+
+    Returns:
+        Path to the downloaded file
+
+    Raises:
+        KeyboardInterrupt: If download is cancelled
+        requests.RequestException: If download fails
+    """
+    global download_cancelled
+    download_cancelled = False
+
+    # Handle local file:// URLs
+    if url.startswith("file://"):
+        local_path = Path(url[7:])  # Remove "file://" prefix
+        if local_path.exists():
+            import shutil
+            output_path.parent.mkdir(parents=True, exist_ok=True)
+            # Copy the file to cache location
+            shutil.copy2(str(local_path), str(output_path))
+            
+            # Update progress bar for cached files
+            if progress_bar:
+                progress_bar(1.0)
+            return output_path
+        else:
+            raise FileNotFoundError(f"Local file not found: {local_path}")
+
+    # Cache check: if file exists and size matches URL's content-length, skip re-download
+    expected_size = None
+    try:
+        head = requests.head(url, timeout=10)
+        expected_size = int(head.headers.get('content-length', 0))
+        if output_path.exists() and output_path.stat().st_size == expected_size:
+            # Cache hit - still update progress to show completion
+            if progress_bar:
+                progress_bar(1.0)
+            return output_path  # Cache hit!
+    except Exception:
+        pass  # Skip cache validation on errors
+
+    output_path.parent.mkdir(parents=True, exist_ok=True)
+
+    session = requests.Session()
+    response = session.get(url, stream=True, timeout=30)
+    response.raise_for_status()
+
+    total_size = expected_size or int(response.headers.get('content-length', 0))
+    block_size = 8192
+
+    # Use TqdmGradio to sync progress with Gradio
+    tqdm_kwargs = {
+        'unit': 'B',
+        'unit_scale': True,
+        'desc': f"Downloading {output_path.name}",
+        'gradio_prog': progress_bar,
+        'disable': False,
+        'bar_format': '{l_bar}{bar}| {n_fmt}/{total_fmt} [{elapsed}<{remaining}]',
+    }
+
+    with open(output_path, "wb") as f:
+        try:
+            for data in TqdmGradio(
+                response.iter_content(block_size),
+                total=total_size // block_size if total_size else 0,
+                **tqdm_kwargs,
+            ):
+                if download_cancelled:
+                    raise KeyboardInterrupt("Download cancelled by user")
+                f.write(data)
+        except KeyboardInterrupt:
+            # Clean partial file on cancel
+            output_path.unlink(missing_ok=True)
+            raise
+
+    return output_path
+
+
+def clear_cache(cache_dir: Path = None, keep_extensions: list[str] = None):
+    """
+    Remove old cache files.
+    
+    Args:
+        cache_dir: Cache directory path (defaults to config.CACHE_DIR)
+        keep_extensions: File extensions to preserve (default: ['.safetensors'])
+    """
+    if cache_dir is None:
+        from .config import CACHE_DIR
+        cache_dir = CACHE_DIR
+    
+    if keep_extensions is None:
+        keep_extensions = ['.safetensors']
+    
+    # Remove temp files
+    for file in cache_dir.glob("*.tmp"):
+        file.unlink()
+    
+    # Optional: age-based cleanup (7 days)
+    # import time
+    # cutoff = time.time() - 86400 * 7
+    # for f in cache_dir.iterdir():
+    #     if f.is_file() and f.stat().st_mtime < cutoff:
+    #         f.unlink()

src/exporter.py

@@ -0,0 +1,134 @@
+"""Model export functionality for SDXL Model Merger."""
+
+import os
+from pathlib import Path
+
+import torch
+from safetensors.torch import save_file
+
+from .config import SCRIPT_DIR, pipe as global_pipe
+
+
+def export_merged_model(
+    include_lora: bool,
+    quantize: bool,
+    qtype: str,
+    save_format: str = "safetensors",
+) -> tuple[str | None, str]:
+    """
+    Export the merged pipeline model with optional LoRA baking and quantization.
+
+    Args:
+        include_lora: Whether to include fused LoRAs in export
+        quantize: Whether to apply quantization
+        qtype: Quantization type - 'none', 'int8', 'int4', or 'float8'
+        save_format: Output format - 'safetensors' or 'bin'
+
+    Returns:
+        Tuple of (output_path or None, status message)
+    """
+    if not global_pipe:
+        return None, "⚠️ Please load a pipeline first."
+
+    try:
+        # Step 1: Unload LoRAs
+        yield "💾 Exporting model...", "Unloading LoRAs..."
+        if include_lora:
+            global_pipe.unload_lora_weights()
+
+        merged_state_dict = {}
+
+        # Step 2: Extract UNet weights
+        yield "💾 Exporting model...", "Extracting UNet weights..."
+        for k, v in global_pipe.unet.state_dict().items():
+            merged_state_dict[f"unet.{k}"] = v.contiguous().half()
+
+        # Step 3: Extract text encoder weights
+        yield "💾 Exporting model...", "Extracting text encoders..."
+        for k, v in global_pipe.text_encoder.state_dict().items():
+            merged_state_dict[f"text_encoder.{k}"] = v.contiguous().half()
+        for k, v in global_pipe.text_encoder_2.state_dict().items():
+            merged_state_dict[f"text_encoder_2.{k}"] = v.contiguous().half()
+
+        # Step 4: Extract VAE weights
+        yield "💾 Exporting model...", "Extracting VAE weights..."
+        for k, v in global_pipe.vae.state_dict().items():
+            merged_state_dict[f"first_stage_model.{k}"] = v.contiguous().half()
+
+        # Step 5: Quantize if requested and optimum.quanto is available
+        try:
+            from optimum.quanto import quantize, QTensor
+            QUANTO_AVAILABLE = True
+        except ImportError:
+            QUANTO_AVAILABLE = False
+
+        if quantize and qtype != "none" and QUANTO_AVAILABLE:
+            yield "💾 Exporting model...", f"Applying {qtype} quantization..."
+            
+            class FakeModel(torch.nn.Module):
+                pass
+
+            fake_model = FakeModel()
+            fake_model.__dict__.update(merged_state_dict)
+
+            # Select quantization method
+            if qtype == "int8":
+                from optimum.quanto import int8_weight_only
+                quantize(fake_model, int8_weight_only())
+            elif qtype == "int4":
+                from optimum.quanto import int4_weight_only
+                quantize(fake_model, int4_weight_only())
+            elif qtype == "float8":
+                from optimum.quanto import float8_dynamic_activation_float8_weight
+                quantize(fake_model, float8_dynamic_activation_float8_weight())
+            else:
+                raise ValueError(f"Unsupported qtype: {qtype}")
+
+            merged_state_dict = {
+                k: v.dequantize().half() if isinstance(v, QTensor) else v
+                for k, v in fake_model.state_dict().items()
+            }
+        elif quantize and not QUANTO_AVAILABLE:
+            return None, "❌ optimum.quanto not installed. Install with: pip install optimum-quanto"
+
+        # Step 6: Save model
+        yield "💾 Exporting model...", "Saving weights..."
+        
+        ext = ".bin" if save_format == "bin" else ".safetensors"
+
+        # Build filename based on options
+        prefix = ""
+        if quantize and qtype != "none":
+            prefix = f"{qtype}_"
+
+        out_path = SCRIPT_DIR / f"merged_{prefix}checkpoint{ext}"
+
+        # Save appropriately
+        if ext == ".bin":
+            torch.save(merged_state_dict, str(out_path))
+        else:
+            save_file(merged_state_dict, str(out_path))
+
+        size_gb = out_path.stat().st_size / 1024**3
+
+        if quantize and qtype != "none":
+            msg = f"✅ Quantized checkpoint saved: `{out_path}` ({size_gb:.2f} GB)"
+        else:
+            msg = f"✅ Merged checkpoint saved: `{out_path}` ({size_gb:.2f} GB)"
+
+        yield "💾 Exporting model...", msg
+        return str(out_path), msg
+
+    except ImportError as e:
+        return None, f"❌ Missing dependency: {str(e)}"
+    except Exception as e:
+        return None, f"❌ Export failed: {str(e)}"
+
+
+def get_export_status() -> str:
+    """Get current export capability status."""
+    try:
+        from optimum.quanto import quantize
+        return "✅ optimum.quanto available for quantization"
+    except ImportError:
+        return "ℹ️ Install optimum-quanto for quantization support"

src/generator.py

@@ -0,0 +1,62 @@
+"""Image generation functions for SDXL Model Merger."""
+
+import torch
+
+from .config import device, dtype, pipe as global_pipe
+from .pipeline import enable_seamless_tiling
+
+
+def generate_image(
+    prompt: str,
+    negative_prompt: str,
+    cfg: float,
+    steps: int,
+    height: int,
+    width: int,
+    tile_x: bool = True,
+    tile_y: bool = False,
+) -> tuple[object | None, str]:
+    """
+    Generate an image using the loaded SDXL pipeline.
+
+    Args:
+        prompt: Positive prompt for image generation
+        negative_prompt: Negative prompt to avoid certain elements
+        cfg: Classifier-Free Guidance scale (1.0-20.0)
+        steps: Number of inference steps (1-50)
+        height: Output image height in pixels
+        width: Output image width in pixels
+        tile_x: Enable seamless tiling on x-axis
+        tile_y: Enable seamless tiling on y-axis
+
+    Returns:
+        Tuple of (PIL Image or None, status message)
+    """
+    if not global_pipe:
+        return None, "⚠️ Please load a pipeline first."
+
+    # Enable seamless tiling on UNet & VAE decoder
+    enable_seamless_tiling(global_pipe.unet, tile_x=tile_x, tile_y=tile_y)
+    enable_seamless_tiling(global_pipe.vae.decoder, tile_x=tile_x, tile_y=tile_y)
+
+    yield "🎨 Generating image...", f"Steps: 0/{steps} | CFG: {cfg}"
+
+    generator = torch.Generator(device=device).manual_seed(42)  # Fixed seed for reproducibility
+    result = global_pipe(
+        prompt=prompt,
+        negative_prompt=negative_prompt,
+        width=int(width),
+        height=int(height),
+        num_inference_steps=int(steps),
+        guidance_scale=float(cfg),
+        generator=generator,
+    )
+
+    image = result.images[0]
+    yield "🎨 Generating image...", f"✅ Complete! ({width}x{height})"
+
+
+def set_pipeline(pipe):
+    """Set the global pipeline instance."""
+    global global_pipe
+    global_pipe = pipe

src/pipeline.py

@@ -0,0 +1,174 @@
+"""Pipeline management for SDXL Model Merger."""
+
+from pathlib import Path
+
+import torch
+from diffusers import (
+    StableDiffusionXLPipeline,
+    AutoencoderKL,
+    DPMSolverSDEScheduler,
+)
+
+from .config import device, dtype, pipe as global_pipe, CACHE_DIR, download_cancelled, device_description
+from .downloader import download_file_with_progress, get_safe_filename_from_url
+
+
+def _make_asymmetric_forward(module, pad_h: int, pad_w: int, tile_x: bool, tile_y: bool):
+    """Create patched forward for seamless tiling on Conv2d layers."""
+    original_forward = module._conv_forward
+
+    def patched_conv_forward(input, weight, bias):
+        if tile_x and tile_y:
+            input = torch.nn.functional.pad(input, (pad_w, pad_w, pad_h, pad_h), mode="circular")
+        elif tile_x:
+            input = torch.nn.functional.pad(input, (pad_w, pad_w, 0, 0), mode="circular")
+            input = torch.nn.functional.pad(input, (0, 0, pad_h, pad_h), mode="constant", value=0)
+        elif tile_y:
+            input = torch.nn.functional.pad(input, (0, 0, pad_h, pad_h), mode="circular")
+            input = torch.nn.functional.pad(input, (pad_w, pad_w, 0, 0), mode="constant", value=0)
+        else:
+            return original_forward(input, weight, bias)
+
+        return torch.nn.functional.conv2d(
+            input, weight, bias, module.stride, (0, 0), module.dilation, module.groups
+        )
+
+    return patched_conv_forward
+
+
+def enable_seamless_tiling(model, tile_x: bool = True, tile_y: bool = False):
+    """
+    Enable seamless tiling on a model's Conv2d layers.
+
+    Args:
+        model: PyTorch model with Conv2d layers (e.g., pipe.unet, pipe.vae.decoder)
+        tile_x: Enable tiling along x-axis
+        tile_y: Enable tiling along y-axis
+    """
+    for module in model.modules():
+        if isinstance(module, torch.nn.Conv2d):
+            pad_h = module.padding[0]
+            pad_w = module.padding[1]
+            if pad_h == 0 and pad_w == 0:
+                continue
+            module._conv_forward = _make_asymmetric_forward(module, pad_h, pad_w, tile_x, tile_y)
+
+
+def load_pipeline(
+    checkpoint_url: str,
+    vae_url: str,
+    lora_urls_str: str,
+    lora_strengths_str: str,
+    progress=None
+) -> tuple[str, str]:
+    """
+    Load SDXL pipeline with checkpoint, VAE, and LoRAs.
+
+    Args:
+        checkpoint_url: URL to base model .safetensors file
+        vae_url: Optional URL to VAE .safetensors file
+        lora_urls_str: Newline-separated URLs for LoRA models
+        lora_strengths_str: Comma-separated strength values for each LoRA
+        progress: Optional gr.Progress() object for UI updates
+
+    Returns:
+        Tuple of (final_status_message, progress_text)
+    """
+    global global_pipe, download_cancelled
+
+    try:
+        checkpoint_filename = get_safe_filename_from_url(checkpoint_url, type_prefix="model")
+        checkpoint_path = CACHE_DIR / checkpoint_filename
+        
+        # VAE: Use suffix="_vae" and default to "vae.safetensors" for proper caching/dropdown matching
+        vae_filename = get_safe_filename_from_url(vae_url, default_name="vae.safetensors", suffix="_vae") if vae_url.strip() else "vae.safetensors"
+        vae_path = CACHE_DIR / vae_filename
+
+        # Download checkpoint
+        if progress:
+            progress(0.1, desc="Downloading base model...")
+        yield f"📥 Downloading {checkpoint_path.name}...", "Starting download..."
+        download_file_with_progress(checkpoint_url, checkpoint_path)
+
+        # Download VAE if provided
+        if vae_url.strip():
+            if progress:
+                progress(0.2, desc="Downloading VAE...")
+            yield f"📥 Downloading {vae_path.name}...", f"Downloading VAE: {vae_path.name}"
+            download_file_with_progress(vae_url, vae_path)
+            vae = AutoencoderKL.from_single_file(str(vae_path), torch_dtype=dtype)
+        else:
+            vae = None
+
+        # Load base pipeline
+        if progress:
+            progress(0.4, desc="Loading SDXL pipeline...")
+        yield f"⚙️ Loading pipeline...", f"Using device: {device_description}"
+        global_pipe = StableDiffusionXLPipeline.from_single_file(
+            str(checkpoint_path),
+            torch_dtype=dtype,
+            use_safetensors=True,
+            safety_checker=None,
+        )
+        if vae:
+            global_pipe.vae = vae.to(device=device, dtype=dtype)
+
+        # Parse LoRA URLs & ensure strengths list matches
+        lora_urls = [u.strip() for u in lora_urls_str.split("\n") if u.strip()]
+        strengths_raw = [s.strip() for s in lora_strengths_str.split(",")]
+        strengths = []
+        for i, url in enumerate(lora_urls):
+            try:
+                val = float(strengths_raw[i]) if i < len(strengths_raw) else 1.0
+                strengths.append(val)
+            except ValueError:
+                strengths.append(1.0)
+
+        # Load and fuse each LoRA sequentially (only if URLs exist)
+        if lora_urls:
+            first_lora_filename = get_safe_filename_from_url(lora_urls[0], "lora_0.safetensors", suffix="_lora")
+            first_lora_path = CACHE_DIR / first_lora_filename
+            yield f"📥 Downloading LoRA: {first_lora_path.name}...", f"Downloading LoRA 1/... ({first_lora_path.name})..."
+            download_file_with_progress(lora_urls[0], first_lora_path)
+
+            global_pipe.load_lora_weights(str(first_lora_path), adapter_name="main_lora")
+            global_pipe.fuse_lora(adapter_names=["main_lora"], lora_scale=strengths[0])
+
+            for i in range(1, len(lora_urls)):
+                lora_filename = get_safe_filename_from_url(lora_urls[i], f"lora_{i}.safetensors", suffix="_lora")
+                lora_path = CACHE_DIR / lora_filename
+                yield f"📥 Downloading LoRA {i+1}...", f"Downloading LoRA {i+1}/{len(lora_urls)} ({lora_path.name})..."
+                download_file_with_progress(lora_urls[i], lora_path)
+
+                global_pipe.unload_lora_weights()
+                global_pipe.load_lora_weights(str(lora_path), adapter_name=f"lora_{i}")
+                # Fuse all loaded adapters so far
+                global_pipe.fuse_lora(
+                    adapter_names=["main_lora"] + [f"lora_{j}" for j in range(1, i+1)],
+                    lora_scale=strengths[i]
+                )
+
+        # Set scheduler and move to device (do this once at the end)
+        yield "⚙️ Finalizing...", "Setting up scheduler..."
+        # Use existing scheduler, just update algorithm_type for DPM++ SDE
+        global_pipe.scheduler.config.algorithm_type = "sde-dpmsolver++"
+        global_pipe = global_pipe.to(device=device, dtype=dtype)
+
+        return ("✅ Pipeline loaded successfully!", f"Ready! Loaded {len(lora_urls)} LoRA(s)")
+
+    except KeyboardInterrupt:
+        download_cancelled = False
+        return ("⚠️ Download cancelled by user", "Cancelled")
+    except Exception as e:
+        return (f"❌ Error loading pipeline: {str(e)}", f"Error: {str(e)}")
+
+
+def cancel_download():
+    """Set the global cancellation flag to stop any ongoing downloads."""
+    global download_cancelled
+    download_cancelled = True
+
+
+def get_pipeline() -> StableDiffusionXLPipeline | None:
+    """Get the currently loaded pipeline."""
+    return global_pipe

src/ui/__init__.py

@@ -0,0 +1,13 @@
+"""UI components for SDXL Model Merger."""
+
+from .header import create_header
+from .loader_tab import create_loader_tab
+from .generator_tab import create_generator_tab
+from .exporter_tab import create_exporter_tab
+
+__all__ = [
+    "create_header",
+    "create_loader_tab", 
+    "create_generator_tab",
+    "create_exporter_tab",
+]

src/ui/exporter_tab.py

@@ -0,0 +1,106 @@
+"""Model exporter tab for SDXL Model Merger."""
+
+import gradio as gr
+
+from ..exporter import export_merged_model
+
+
+def create_exporter_tab():
+    """Create the model export tab with all configuration options."""
+    
+    with gr.Accordion("📦 3. Export Merged Model", open=True, elem_classes=["feature-card"]):
+        # Export settings
+        with gr.Row():
+            include_lora = gr.Checkbox(
+                True,
+                label="Include Fused LoRAs",
+                info="Bake the loaded LoRAs into the exported model"
+            )
+            
+            quantize_toggle = gr.Checkbox(
+                False,
+                label="Apply Quantization",
+                info="Reduce model size with quantization"
+            )
+        
+        # Quantization options
+        with gr.Row(visible=True) as qtype_row:
+            qtype_dropdown = gr.Dropdown(
+                choices=["none", "int8", "int4", "float8"],
+                value="int8",
+                label="Quantization Method",
+                info="Trade quality for smaller file size"
+            )
+        
+        # Format options
+        with gr.Row():
+            format_dropdown = gr.Dropdown(
+                choices=["safetensors", "bin"],
+                value="safetensors",
+                label="Export Format",
+                info="safetensors is recommended for safety"
+            )
+        
+        # Export button and output
+        with gr.Row():
+            export_btn = gr.Button("💾 Save Merged Checkpoint", variant="primary", size="lg")
+        
+        with gr.Row():
+            download_link = gr.File(
+                label="Download Merged File",
+                show_label=True,
+            )
+            
+            with gr.Column():
+                export_status = gr.Textbox(
+                    label="Export Status",
+                    placeholder="Ready to export..."
+                )
+                
+                # Info about quantization
+                gr.HTML("""
+                    <div style="margin-top: 16px; padding: 12px; background: #e0f2fe; border-radius: 8px;">
+                        <strong>ℹ️ About Quantization:</strong>
+                        <p style="font-size: 0.9em; margin: 8px 0;">
+                            Reduces model size by lowering precision. Int8 is typically 
+                            lossless for inference while cutting size in half.
+                        </p>
+                    </div>
+                """)
+    
+    return (
+        include_lora, quantize_toggle, qtype_dropdown, format_dropdown,
+        export_btn, download_link, export_status, qtype_row
+    )
+
+
+def setup_exporter_events(
+    include_lora, quantize_toggle, qtype_dropdown, format_dropdown,
+    export_btn, download_link, export_status, qtype_row
+):
+    """Setup event handlers for the exporter tab."""
+    
+    # Toggle quantization row visibility
+    quantize_toggle.change(
+        fn=lambda checked: gr.update(visible=checked),
+        inputs=[quantize_toggle],
+        outputs=qtype_row,
+    )
+    
+    # Clear download link after use
+    def clear_download_link():
+        return None
+    
+    export_btn.click(
+        fn=lambda inc, q, qt, fmt: export_merged_model(
+            include_lora=inc,
+            quantize=q and (qt != "none"),
+            qtype=qt if qt != "none" else None,
+            save_format=fmt,
+        ),
+        inputs=[include_lora, quantize_toggle, qtype_dropdown, format_dropdown],
+        outputs=[download_link, export_status],
+    ).then(
+        fn=clear_download_link,
+        outputs=[download_link],
+    )

src/ui/generator_tab.py

@@ -0,0 +1,104 @@
+"""Image generator tab for SDXL Model Merger."""
+
+import gradio as gr
+
+from ..config import DEFAULT_PROMPT, DEFAULT_NEGATIVE_PROMPT
+from ..generator import generate_image
+
+
+def create_generator_tab():
+    """Create the image generation tab with all input controls."""
+    
+    with gr.Accordion("🎨 2. Generate Image", open=True, elem_classes=["feature-card"]):
+        # Prompts section
+        with gr.Row():
+            with gr.Column(scale=1):
+                prompt = gr.Textbox(
+                    label="Positive Prompt",
+                    value=DEFAULT_PROMPT,
+                    lines=3,
+                    placeholder="Describe the image you want to generate..."
+                )
+                
+                cfg = gr.Slider(
+                    minimum=1.0, maximum=20.0, value=7.5, step=0.5,
+                    label="CFG Scale",
+                    info="Higher values make outputs match prompt more strictly"
+                )
+                
+                height = gr.Number(
+                    value=1024, precision=0,
+                    label="Height (pixels)",
+                    info="Output image height"
+                )
+            
+            with gr.Column(scale=1):
+                negative_prompt = gr.Textbox(
+                    label="Negative Prompt",
+                    value=DEFAULT_NEGATIVE_PROMPT,
+                    lines=3,
+                    placeholder="Elements to avoid in generation..."
+                )
+                
+                steps = gr.Slider(
+                    minimum=1, maximum=100, value=25, step=1,
+                    label="Inference Steps",
+                    info="More steps = better quality but slower"
+                )
+                
+                width = gr.Number(
+                    value=2048, precision=0,
+                    label="Width (pixels)",
+                    info="Output image width"
+                )
+        
+        # Tiling options
+        with gr.Row():
+            tile_x = gr.Checkbox(True, label="X-axis Seamless Tiling")
+            tile_y = gr.Checkbox(False, label="Y-axis Seamless Tiling")
+        
+        # Generate button and outputs
+        with gr.Row():
+            gen_btn = gr.Button("✨ Generate Image", variant="secondary", size="lg")
+        
+        with gr.Row():
+            image_output = gr.Image(
+                label="Result",
+                height=400,
+                show_label=True
+            )
+            with gr.Column():
+                gen_status = gr.Textbox(
+                    label="Generation Status",
+                    placeholder="Ready to generate..."
+                )
+                
+                # Quick tips
+                gr.HTML("""
+                    <div style="margin-top: 16px; padding: 12px; background: #f3f4f6; border-radius: 8px;">
+                        <strong>💡 Tips:</strong>
+                        <ul style="margin: 8px 0; padding-left: 20px; font-size: 0.9em;">
+                            <li>Use wide aspect ratios (e.g., 1024x2048) for panoramas</li>
+                            <li>Enable seamless tiling for texture-like outputs</li>
+                            <li>Lower CFG (3-5) for more creative results</li>
+                        </ul>
+                    </div>
+                """)
+    
+    return (
+        prompt, negative_prompt, cfg, steps, height, width,
+        tile_x, tile_y, gen_btn, image_output, gen_status
+    )
+
+
+def setup_generator_events(
+    prompt, negative_prompt, cfg, steps, height, width,
+    tile_x, tile_y, gen_btn, image_output, gen_status
+):
+    """Setup event handlers for the generator tab."""
+    
+    gen_btn.click(
+        fn=generate_image,
+        inputs=[prompt, negative_prompt, cfg, steps, height, width, tile_x, tile_y],
+        outputs=[image_output, gen_status],
+    )

src/ui/header.py

@@ -0,0 +1,129 @@
+"""Header component with title and styling for SDXL Model Merger."""
+
+import gradio as gr
+
+
+def create_header():
+    """Create the header section with title, description, and custom styling."""
+    
+    # Custom CSS for modern look
+    css = """
+    /* Header gradient text */
+    .header-gradient {
+        background: linear-gradient(135deg, #10b981 0%, #7c3aed 100%);
+        -webkit-background-clip: text;
+        -webkit-text-fill-color: transparent;
+        background-clip: text;
+    }
+    
+    /* Feature cards */
+    .feature-card {
+        border-radius: 12px;
+        padding: 20px;
+        margin-bottom: 16px;
+        box-shadow: 0 4px 6px -1px rgba(0, 0, 0, 0.1);
+        transition: transform 0.2s ease;
+    }
+    
+    .feature-card:hover {
+        transform: translateY(-2px);
+        box-shadow: 0 10px 15px -3px rgba(0, 0, 0, 0.1);
+    }
+    
+    /* Label styling */
+    .gradio-container .label {
+        font-weight: 600;
+        color: #374151;
+        margin-bottom: 8px;
+    }
+    
+    /* Status message colors */
+    .status-success { 
+        color: #059669 !important; 
+        font-weight: 600;
+    }
+    .status-error { 
+        color: #dc2626 !important; 
+        font-weight: 600;
+    }
+    .status-warning { 
+        color: #d97706 !important; 
+        font-weight: 600;
+    }
+    
+    /* Button improvements */
+    .gradio-container .btn {
+        border-radius: 8px;
+        padding: 12px 24px;
+        font-weight: 600;
+    }
+    
+    /* Input field styling */
+    .gradio-container textarea, 
+    .gradio-container input[type="number"],
+    .gradio-container input[type="text"] {
+        border-radius: 8px;
+        border-color: #d1d5db;
+    }
+    
+    .gradio-container textarea:focus,
+    .gradio-container input:focus {
+        outline: none;
+        border-color: #6366f1;
+        box-shadow: 0 0 0 3px rgba(99, 102, 241, 0.1);
+    }
+    
+    /* Tab styling */
+    .gradio-container .tabitem {
+        background: transparent;
+        border-radius: 12px;
+    }
+    
+    /* Progress bar improvements */
+    .gradio-container .progress-bar {
+        border-radius: 8px;
+        overflow: hidden;
+    }
+    """
+    
+    with gr.Column(elem_classes=["feature-card"]):
+        gr.HTML("""
+            <div style="text-align: center; margin-bottom: 24px;">
+                <h1 style="font-size: 2.5em; margin: 0; line-height: 1.2;">
+                    <span class="header-gradient">SDXL Model Merger</span>
+                </h1>
+                <p style="color: #6b7280; font-size: 1.1em; max-width: 600px; margin: 16px auto;">
+                    Merge checkpoints, LoRAs, and VAEs — then bake LoRAs into a single exportable 
+                    checkpoint with optional quantization.
+                </p>
+            </div>
+        """)
+        
+        # Feature highlights
+        with gr.Row():
+            with gr.Column(scale=1):
+                gr.HTML("""
+                    <div style="text-align: center; padding: 16px;">
+                        <div style="font-size: 2.5em; margin-bottom: 8px;">🚀</div>
+                        <strong>Fast Loading</strong>
+                        <p style="font-size: 0.85em; color: #6b7280; margin-top: 4px;">With progress tracking & cache</p>
+                    </div>
+                """)
+            with gr.Column(scale=1):
+                gr.HTML("""
+                    <div style="text-align: center; padding: 16px;">
+                        <div style="font-size: 2.5em; margin-bottom: 8px;">🎨</div>
+                        <strong>Panorama Gen</strong>
+                        <p style="font-size: 0.85em; color: #6b7280; margin-top: 4px;">Seamless tiling support</p>
+                    </div>
+                """)
+            with gr.Column(scale=1):
+                gr.HTML("""
+                    <div style="text-align: center; padding: 16px;">
+                        <div style="font-size: 2.5em; margin-bottom: 8px;">📦</div>
+                        <strong>Export Ready</strong>
+                        <p style="font-size: 0.85em; color: #6b7280; margin-top: 4px;">Quantization & format options</p>
+                    </div>
+                """)
+
+    return css

src/ui/loader_tab.py

@@ -0,0 +1,83 @@
+"""Pipeline loader tab for SDXL Model Merger."""
+
+import gradio as gr
+
+from ..config import (
+    DEFAULT_CHECKPOINT_URL,
+    DEFAULT_VAE_URL,
+    DEFAULT_LORA_URLS,
+)
+from ..pipeline import load_pipeline, cancel_download
+
+
+def create_loader_tab():
+    """Create the pipeline loading tab with all input controls."""
+
+    with gr.Accordion("⚙️ 1. Load Pipeline", open=True, elem_classes=["feature-card"]):
+        with gr.Row():
+            with gr.Column(scale=2):
+                # Checkpoint URL
+                checkpoint_url = gr.Textbox(
+                    label="Base Model (.safetensors) URL",
+                    value=DEFAULT_CHECKPOINT_URL,
+                    placeholder="e.g., https://civitai.com/api/download/models/...",
+                    info="Download link for the base SDXL checkpoint"
+                )
+
+                # VAE URL (optional)
+                vae_url = gr.Textbox(
+                    label="VAE (.safetensors) URL",
+                    value=DEFAULT_VAE_URL,
+                    placeholder="Leave blank to use model's built-in VAE",
+                    info="Optional custom VAE for improved quality"
+                )
+
+            with gr.Column(scale=1):
+                # LoRA URLs
+                lora_urls = gr.Textbox(
+                    label="LoRA URLs (one per line)",
+                    lines=5,
+                    value=DEFAULT_LORA_URLS,
+                    placeholder="https://civit.ai/...\nhttps://huggingface.co/...",
+                    info="Multiple LoRAs can be loaded and fused together"
+                )
+                
+                # LoRA strengths
+                lora_strengths = gr.Textbox(
+                    label="LoRA Strengths",
+                    value="1.0",
+                    placeholder="e.g., 0.8,1.0,0.5",
+                    info="Comma-separated strength values for each LoRA"
+                )
+        
+        # Action buttons
+        with gr.Row():
+            load_btn = gr.Button("🚀 Load Pipeline", variant="primary", size="lg")
+            cancel_btn = gr.Button("🛑 Cancel Download", variant="stop", size="lg")
+        
+        # Status output
+        load_status = gr.Textbox(
+            label="Status",
+            placeholder="Ready to load pipeline...",
+            show_label=True,
+        )
+    
+    return (
+        checkpoint_url, vae_url, lora_urls, lora_strengths,
+        load_btn, cancel_btn, load_status
+    )
+
+
+def setup_loader_events(
+    checkpoint_url, vae_url, lora_urls, lora_strengths,
+    load_btn, cancel_btn, load_status
+):
+    """Setup event handlers for the loader tab."""
+    
+    load_btn.click(
+        fn=load_pipeline,
+        inputs=[checkpoint_url, vae_url, lora_urls, lora_strengths],
+        outputs=load_status,
+    )
+    
+    cancel_btn.click(fn=cancel_download)