updated code to include lora adapters

.gitignore

@@ -0,0 +1,213 @@
+# Byte-compiled / optimized / DLL files
+__pycache__/
+*.py[codz]
+*$py.class
+
+# C extensions
+*.so
+
+# Distribution / packaging
+.Python
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+share/python-wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+MANIFEST
+
+# PyInstaller
+#  Usually these files are written by a python script from a template
+#  before PyInstaller builds the exe, so as to inject date/other infos into it.
+*.manifest
+*.spec
+
+# Installer logs
+pip-log.txt
+pip-delete-this-directory.txt
+
+# Unit test / coverage reports
+htmlcov/
+.tox/
+.nox/
+.coverage
+.coverage.*
+.cache
+nosetests.xml
+coverage.xml
+*.cover
+*.py.cover
+.hypothesis/
+.pytest_cache/
+cover/
+
+# Translations
+*.mo
+*.pot
+
+# Django stuff:
+*.log
+local_settings.py
+db.sqlite3
+db.sqlite3-journal
+
+# Flask stuff:
+instance/
+.webassets-cache
+
+# Scrapy stuff:
+.scrapy
+
+# Sphinx documentation
+docs/_build/
+
+# PyBuilder
+.pybuilder/
+target/
+
+# Jupyter Notebook
+.ipynb_checkpoints
+
+# IPython
+profile_default/
+ipython_config.py
+
+# pyenv
+#   For a library or package, you might want to ignore these files since the code is
+#   intended to run in multiple environments; otherwise, check them in:
+# .python-version
+
+# pipenv
+#   According to pypa/pipenv#598, it is recommended to include Pipfile.lock in version control.
+#   However, in case of collaboration, if having platform-specific dependencies or dependencies
+#   having no cross-platform support, pipenv may install dependencies that don't work, or not
+#   install all needed dependencies.
+#Pipfile.lock
+
+# UV
+#   Similar to Pipfile.lock, it is generally recommended to include uv.lock in version control.
+#   This is especially recommended for binary packages to ensure reproducibility, and is more
+#   commonly ignored for libraries.
+#uv.lock
+
+# poetry
+#   Similar to Pipfile.lock, it is generally recommended to include poetry.lock in version control.
+#   This is especially recommended for binary packages to ensure reproducibility, and is more
+#   commonly ignored for libraries.
+#   https://python-poetry.org/docs/basic-usage/#commit-your-poetrylock-file-to-version-control
+#poetry.lock
+#poetry.toml
+
+# pdm
+#   Similar to Pipfile.lock, it is generally recommended to include pdm.lock in version control.
+#   pdm recommends including project-wide configuration in pdm.toml, but excluding .pdm-python.
+#   https://pdm-project.org/en/latest/usage/project/#working-with-version-control
+#pdm.lock
+#pdm.toml
+.pdm-python
+.pdm-build/
+
+# pixi
+#   Similar to Pipfile.lock, it is generally recommended to include pixi.lock in version control.
+#pixi.lock
+#   Pixi creates a virtual environment in the .pixi directory, just like venv module creates one
+#   in the .venv directory. It is recommended not to include this directory in version control.
+.pixi
+
+# PEP 582; used by e.g. github.com/David-OConnor/pyflow and github.com/pdm-project/pdm
+__pypackages__/
+
+# Celery stuff
+celerybeat-schedule
+celerybeat.pid
+
+# SageMath parsed files
+*.sage.py
+
+# Environments
+.env
+.envrc
+.venv
+env/
+venv/
+ENV/
+env.bak/
+venv.bak/
+
+# Spyder project settings
+.spyderproject
+.spyproject
+
+# Rope project settings
+.ropeproject
+
+# mkdocs documentation
+/site
+
+# mypy
+.mypy_cache/
+.dmypy.json
+dmypy.json
+
+# Pyre type checker
+.pyre/
+
+# pytype static type analyzer
+.pytype/
+
+# Cython debug symbols
+cython_debug/
+
+# PyCharm
+#  JetBrains specific template is maintained in a separate JetBrains.gitignore that can
+#  be found at https://github.com/github/gitignore/blob/main/Global/JetBrains.gitignore
+#  and can be added to the global gitignore or merged into this file.  For a more nuclear
+#  option (not recommended) you can uncomment the following to ignore the entire idea folder.
+#.idea/
+
+# Abstra
+# Abstra is an AI-powered process automation framework.
+# Ignore directories containing user credentials, local state, and settings.
+# Learn more at https://abstra.io/docs
+.abstra/
+
+# Visual Studio Code
+#  Visual Studio Code specific template is maintained in a separate VisualStudioCode.gitignore 
+#  that can be found at https://github.com/github/gitignore/blob/main/Global/VisualStudioCode.gitignore
+#  and can be added to the global gitignore or merged into this file. However, if you prefer, 
+#  you could uncomment the following to ignore the entire vscode folder
+# .vscode/
+
+# Ruff stuff:
+.ruff_cache/
+
+# PyPI configuration file
+.pypirc
+
+# Cursor
+#  Cursor is an AI-powered code editor. `.cursorignore` specifies files/directories to
+#  exclude from AI features like autocomplete and code analysis. Recommended for sensitive data
+#  refer to https://docs.cursor.com/context/ignore-files
+.cursorignore
+.cursorindexingignore
+
+# Marimo
+marimo/_static/
+marimo/_lsp/
+__marimo__/
+
+src/assets/history
+*.ckpt
+*.pt
+*.bin
+*.pth

README.md

@@ -142,6 +142,7 @@ Install core libs:
 
 ```bash
 pip install -r requirements.txt
+pip install -e .
 ```
 
 ### 4. HuggingFace Login (optional)

requirements.txt

@@ -11,8 +11,9 @@ torchaudio==2.5.1
 diffusers==0.35.2
 transformers==4.57.3    
 huggingface_hub==0.36.0
-accelerate==0.28.0
+accelerate==0.33.0
 safetensors==0.7.0
+peft==0.17.1
 
 
 # UI FRAMEWORK

src/sdgen/main.py

@@ -6,8 +6,8 @@ sets up the UI, and launches the Gradio interface.
 
 from __future__ import annotations
 
-import sys
 import os
+import sys
 
 # for HF spaces
 sys.path.append(os.path.abspath("src"))
@@ -45,7 +45,7 @@ def main() -> None:
     model_id1 = settings.model_id1
     model_id2 = settings.model_id2
 
-    device = detect_device()
+    device = "cpu"
 
     logger.info("Loading pipeline %s", model_id1)
     pipes = {

src/sdgen/presets/styles.py

@@ -1,65 +1,82 @@
-"""Preset configurations for text-to-image generation.
-
-This module defines a collection of named presets including prompt,
-negative prompt, sampler parameters, and recommended resolutions.
-"""
+"""Preset configurations."""
 
 from __future__ import annotations
 
 from typing import Any, Dict, List
 
-# Global preset registry: {preset_name: parameters}
 PRESETS: Dict[str, Dict[str, Any]] = {
-    "Realistic Photo": {
+    "Cinematic Realism": {
         "prompt": (
-            "ultra realistic, 35mm photography, \
-photorealistic, cinematic lighting"
+            "ultra realistic, cinematic lighting, 35mm film look, depth "
+            "of field, sharp focus, natural skin texture"
         ),
-        "negative_prompt": "low quality, blurry, deformed, extra limbs",
-        "tags": ["realistic", "photo"],
-    },
-    "Anime": {
-        "prompt": (
-            "high quality anime, clean lines, vibrant colors, \
-soft rim lighting, studio lighting"
+        "negative_prompt": (
+            "lowres, blurry, deformed anatomy, \
+extra limbs, oversaturated, jpeg artifacts"
         ),
-        "negative_prompt": "blurry, low detail, mutation, deformed",
-        "tags": ["anime", "stylized"],
-    },
-    "Cinematic / Moody": {
-        "prompt": (
-            "dramatic cinematic lighting, moody, film grain, \
-Kodak Portra, filmic color grading"
-        ),
-        "negative_prompt": "oversaturated, low detail, flat lighting",
-        "tags": ["cinematic", "moody"],
+        "steps": 24,
+        "cfg": 6.5,
+        "width": 768,
+        "height": 512,
+        "lora_A": "DetailTweak.safetensors",
+        "alpha_A": 0.8,
+        "lora_B": None,
+        "alpha_B": 0.0,
     },
     "Oil Painting / Classic Art": {
         "prompt": (
-            "oil painting, impasto brush strokes, classical \
+            "oil painting, impasto brush strokes, classical \ \
 lighting, Rembrandt style"
         ),
         "negative_prompt": "blurry, cartoonish, digital artifacts",
-        "tags": ["art", "oil", "painterly"],
+        "steps": 20,
+        "cfg": 7.5,
+        "width": 512,
+        "height": 512,
+        "lora_A": "DetailTweak.safetensors",
+        "alpha_A": 0.4,
+        "lora_B": None,
+        "alpha_B": 0.0,
+    },
+    "Manga Illustration": {
+        "prompt": (
+            "manga illustration, clean line art, expressive pose, full "
+            "background, detailed composition"
+        ),
+        "negative_prompt": "badhandsv4, easyn, blurry line art",
+        "steps": 20,
+        "cfg": 7.0,
+        "width": 512,
+        "height": 704,
+        "lora_A": "MangaPanels.safetensors",
+        "alpha_A": 1.0,
+        "lora_B": None,
+        "alpha_B": 0.0,
     },
-    "Cyberpunk / Neon": {
+    "Anime Tarot": {
         "prompt": (
-            "cyberpunk city, neon reflections, wet streets, \
-high detail, synthwave aesthetic"
+            "anime tarot card, ornate composition, symbolic character pose, "
+            "intricate patterns, layered design"
         ),
-        "negative_prompt": "low detail, daytime, blurry",
-        "tags": ["cyberpunk", "neon"],
+        "negative_prompt": "badhandsv4, flat background, simple layout",
+        "steps": 20,
+        "cfg": 6.0,
+        "width": 512,
+        "height": 704,
+        "lora_A": "AnimeTarotCards.safetensors",
+        "alpha_A": 1.0,
+        "lora_B": "DetailTweak.safetensors",
+        "alpha_B": -0.4,
     },
 }
 
 
 def get_preset(name: str) -> Dict[str, Any] | None:
-    """Return a shallow copy of a preset by name."""
+    """Return shallow copy of a preset config."""
     data = PRESETS.get(name)
     return dict(data) if data else None
 
 
 def list_presets() -> List[str]:
-    """List preset names in a stable UI order."""
-    # Avoid unexpected reordering: use insertion order
+    """Stable UI order."""
     return list(PRESETS.keys())

src/sdgen/sd/__init__.py

@@ -2,6 +2,7 @@ from __future__ import annotations
 
 from .generator import generate_image
 from .img2img import generate_img2img, prepare_img2img_pipeline
+from .lora_loader import apply_loras, get_lora_path, list_loras
 from .models import GenerationMetadata, HistorySummary, Img2ImgConfig, Txt2ImgConfig
 from .pipeline import load_pipeline, warmup_pipeline
 
@@ -15,4 +16,7 @@ __all__ = [
     "prepare_img2img_pipeline",
     "load_pipeline",
     "warmup_pipeline",
+    "list_loras",
+    "get_lora_path",
+    "apply_loras",
 ]

src/sdgen/sd/lora_loader.py

@@ -0,0 +1,69 @@
+"""LORA Adapter loader module."""
+
+from __future__ import annotations
+
+from pathlib import Path
+from typing import List, Optional
+
+from sdgen.config import ASSETS_ROOT
+
+# Assets/loras lives under src/assets/loras
+LORA_DIR: Path = ASSETS_ROOT / "loras"
+LORA_DIR.mkdir(parents=True, exist_ok=True)
+
+
+def list_loras() -> List[str]:
+    """Return a sorted list of available LoRA checkpoint filenames."""
+    if not LORA_DIR.exists():
+        return []
+    return sorted([p.name for p in LORA_DIR.glob("*.safetensors")])
+
+
+def get_lora_path(name: str) -> str:
+    """Return the absolute path for a given LoRA filename."""
+    return str(LORA_DIR / name)
+
+
+def apply_loras(
+    pipe,
+    lora_a_name: Optional[str],
+    alpha_a: float,
+    lora_b_name: Optional[str],
+    alpha_b: float,
+) -> None:
+    """Apply up to two LoRA adapters to the given pipeline.
+
+    Uses diffusers' load_lora_weights / set_adapters API.
+
+    Args:
+        pipe: A Stable Diffusion pipeline instance.
+        lora_a_name: Filename of first LoRA (or None).
+        alpha_a: Weight for first LoRA.
+        lora_b_name: Filename of second LoRA (or None).
+        alpha_b: Weight for second LoRA.
+    """
+    # If the pipeline supports unloading adapters, clear previous ones
+    if hasattr(pipe, "unload_lora_weights"):
+        pipe.unload_lora_weights()
+
+    adapters = []
+    weights = []
+
+    if lora_a_name:
+        pipe.load_lora_weights(
+            get_lora_path(lora_a_name),
+            adapter_name=Path(lora_a_name).stem,
+        )
+        adapters.append(Path(lora_a_name).stem)
+        weights.append(float(alpha_a))
+
+    if lora_b_name:
+        pipe.load_lora_weights(
+            get_lora_path(lora_b_name),
+            adapter_name=Path(lora_b_name).stem,
+        )
+        adapters.append(Path(lora_b_name).stem)
+        weights.append(float(alpha_b))
+
+    if adapters and hasattr(pipe, "set_adapters"):
+        pipe.set_adapters(adapters, weights)

src/sdgen/sd/models.py

@@ -4,7 +4,7 @@ from __future__ import annotations
 
 from dataclasses import asdict, dataclass, field
 from datetime import datetime
-from typing import Any, Dict, Optional
+from typing import Any, Dict, List, Optional
 
 
 @dataclass
@@ -79,6 +79,7 @@ class GenerationMetadata:
     id: Optional[str] = None
     thumbnail: Optional[str] = None
     full_image: Optional[str] = None
+    model_id: Optional[str] = None
 
     # Txt2Img / Img2Img
     prompt: Optional[str] = None
@@ -86,6 +87,8 @@ class GenerationMetadata:
     steps: Optional[int] = None
     guidance_scale: Optional[float] = None
     seed: Optional[int] = None
+    lora_names: Optional[List[str]] = None
+    lora_alphas: Optional[List[float]] = None
 
     # Img2Img only
     strength: Optional[float] = None

src/sdgen/ui/layout.py

@@ -6,9 +6,14 @@ from typing import Any, Tuple
 
 import gradio as gr
 
-from sdgen.sd.generator import generate_image
-from sdgen.sd.img2img import generate_img2img
-from sdgen.sd.models import Img2ImgConfig, Txt2ImgConfig
+from sdgen.sd import (
+    Img2ImgConfig,
+    Txt2ImgConfig,
+    apply_loras,
+    generate_image,
+    generate_img2img,
+    list_loras,
+)
 from sdgen.ui.tabs import (
     build_history_tab,
     build_img2img_tab,
@@ -24,38 +29,154 @@ from sdgen.utils.logger import get_logger
 logger = get_logger(__name__)
 
 
+# Small helpers
+
+
 def _resolve_seed(value: Any) -> int | None:
     """Return integer seed if valid, otherwise None."""
     if value is None:
         return None
     if isinstance(value, int):
         return value
+
     text = str(value).strip()
     if not text:
         return None
+
     try:
         return int(text)
     except ValueError:
-        logger.warning("Invalid seed input: %s", value)
+        logger.warning("Invalid seed input for seed: %s", value)
+        return None
+
+
+def _normalize_lora_name(raw: Any) -> str | None:
+    """Normalize dropdown value to a LoRA filename or None."""
+    if raw is None:
         return None
+    name = str(raw).strip()
+    if not name or name == "(none)":
+        return None
+    return name
 
 
-def _update_steps_and_cfg(model):
-    """Upate steps based on the model."""
+def _steps_cfg_for_model(model: str) -> Tuple[gr.update, gr.update]:
+    """Return UI updates for steps & CFG when the model changes."""
     if model == "Turbo":
+        # Turbo: super low steps, CFG has no meaningful effect.
         return (
             gr.update(minimum=1, maximum=5, value=2, step=1),
             gr.update(minimum=0, maximum=0, value=0, step=0),
         )
+
+    # SD1.5 defaults
     return (
         gr.update(minimum=10, maximum=30, value=20, step=1),
         gr.update(minimum=1, maximum=10, value=5, step=1),
     )
 
 
+def _validate_turbo_strength(
+    model: str,
+    steps: float,
+    strength: float,
+) -> Tuple[gr.update, gr.update, str]:
+    """UI constraint: Turbo requires steps * strength >= 1."""
+    if model != "Turbo":
+        return gr.update(), gr.update(), ""
+
+    product = float(steps) * float(strength)
+    if product >= 1.0:
+        return gr.update(), gr.update(), f"Turbo OK: {product:.2f} ≥ 1"
+
+    required = 1.0 / float(steps)
+    required = min(required, 1.0)
+    return (
+        gr.update(),
+        gr.update(value=required),
+        "Adjusted for Turbo: steps×strength must be ≥ 1",
+    )
+
+
+def _update_model_dependents(model: str):
+    """update.
+
+    - steps & cfg sliders for txt2img and img2img
+    - LoRA panel visibility
+    """
+    steps_t2i, cfg_t2i = _steps_cfg_for_model(model)
+    steps_i2i, cfg_i2i = _steps_cfg_for_model(model)
+    lora_visibility = gr.update(visible=(model == "SD1.5"))
+
+    return (
+        steps_t2i,
+        cfg_t2i,
+        steps_i2i,
+        cfg_i2i,
+        lora_visibility,
+    )
+
+
+def _apply_lora_if_allowed(
+    model: str,
+    pipe: Any,
+    lora_a: str | None,
+    alpha_a: float,
+    lora_b: str | None,
+    alpha_b: float,
+) -> Tuple[list[str], list[float]]:
+    """Apply up to two LoRA adapters to the given pipeline.
+
+    - Only applied for SD1.5.
+    - Turbo completely ignores LoRA (and unloads any existing ones).
+    - Returns (active_lora_names, active_lora_alphas) for metadata.
+    """
+    if model != "SD1.5":
+        if hasattr(pipe, "unload_lora_weights"):
+            try:
+                pipe.unload_lora_weights()
+            except Exception as exc:  # noqa: BLE001
+                logger.warning("Failed to unload LoRA weights: %s", exc)
+        return [], []
+
+    names: list[str] = []
+    alphas: list[float] = []
+
+    # Filter out zero-weight adapters to keep metadata clean.
+    if lora_a and alpha_a != 0:
+        names.append(lora_a)
+        alphas.append(float(alpha_a))
+
+    if lora_b and alpha_b != 0:
+        names.append(lora_b)
+        alphas.append(float(alpha_b))
+
+    if not names:
+        # Nothing to apply
+        if hasattr(pipe, "unload_lora_weights"):
+            try:
+                pipe.unload_lora_weights()
+            except Exception as exc:  # noqa: BLE001
+                logger.warning("Failed to unload LoRA weights: %s", exc)
+        return [], []
+
+    apply_loras(
+        pipe,
+        names[0] if len(names) > 0 else None,
+        alphas[0] if len(alphas) > 0 else 0.0,
+        names[1] if len(names) > 1 else None,
+        alphas[1] if len(alphas) > 1 else 0.0,
+    )
+
+    return names, alphas
+
+
+# Core handlers
+
+
 def _txt2img_handler(
-    model_choice: str,
-    pipes: dict,
+    model: str,
+    pipes: dict[str, Any],
     prompt: str,
     negative: str,
     steps: int,
@@ -63,11 +184,28 @@ def _txt2img_handler(
     width: int,
     height: int,
     seed: Any,
+    lora_a_value: Any,
+    lora_a_alpha_value: Any,
+    lora_b_value: Any,
+    lora_b_alpha_value: Any,
 ) -> Tuple[Any, str]:
     """Run text-to-image generation."""
-    model = model_choice
     pipe = pipes[model]
 
+    lora_a = _normalize_lora_name(lora_a_value)
+    lora_b = _normalize_lora_name(lora_b_value)
+    alpha_a = float(lora_a_alpha_value or 0.0)
+    alpha_b = float(lora_b_alpha_value or 0.0)
+
+    active_lora_names, active_lora_alphas = _apply_lora_if_allowed(
+        model,
+        pipe,
+        lora_a,
+        alpha_a,
+        lora_b,
+        alpha_b,
+    )
+
     cfg = Txt2ImgConfig(
         prompt=prompt or "",
         negative_prompt=negative or "",
@@ -80,6 +218,9 @@ def _txt2img_handler(
     )
 
     image, meta = generate_image(pipe, cfg)
+    meta.model_id = model
+    meta.lora_names = active_lora_names
+    meta.lora_alphas = active_lora_alphas
 
     try:
         save_history_entry(meta, image)
@@ -90,8 +231,8 @@ def _txt2img_handler(
 
 
 def _img2img_handler(
-    model_choice: str,
-    pipes: dict,
+    model: str,
+    pipes: dict[str, Any],
     input_image: Any,
     prompt: str,
     negative: str,
@@ -99,9 +240,12 @@ def _img2img_handler(
     steps: int,
     guidance: float,
     seed: Any,
+    lora_a_value: Any,
+    lora_a_alpha_value: Any,
+    lora_b_value: Any,
+    lora_b_alpha_value: Any,
 ) -> Tuple[Any, str]:
     """Run image-to-image generation."""
-    model = model_choice
     pipe = pipes[model]
 
     if input_image is None:
@@ -109,6 +253,20 @@ def _img2img_handler(
 
     pil_image = to_pil(input_image)
 
+    lora_a = _normalize_lora_name(lora_a_value)
+    lora_b = _normalize_lora_name(lora_b_value)
+    alpha_a = float(lora_a_alpha_value or 0.0)
+    alpha_b = float(lora_b_alpha_value or 0.0)
+
+    active_lora_names, active_lora_alphas = _apply_lora_if_allowed(
+        model,
+        pipe,
+        lora_a,
+        alpha_a,
+        lora_b,
+        alpha_b,
+    )
+
     cfg = Img2ImgConfig(
         prompt=prompt or "",
         negative_prompt=negative or "",
@@ -122,6 +280,9 @@ def _img2img_handler(
     )
 
     image, meta = generate_img2img(pipe, cfg, pil_image)
+    meta.model_id = model
+    meta.lora_names = active_lora_names
+    meta.lora_alphas = active_lora_alphas
 
     try:
         save_history_entry(meta, image)
@@ -141,7 +302,6 @@ def _upscale_handler(
 
     pil_image = to_pil(input_image)
 
-    # scale is str → convert to int
     try:
         scale_int = int(float(scale))
     except Exception as exc:  # noqa: BLE001
@@ -149,6 +309,7 @@ def _upscale_handler(
 
     upscaler = Upscaler(scale=scale_int, prefer="ncnn")
     out_image, meta = upscaler.upscale(pil_image)
+    meta.model_id = "RealESRGAN"
 
     try:
         save_history_entry(meta, out_image)
@@ -158,104 +319,191 @@ def _upscale_handler(
     return out_image, pretty_json(meta.to_dict())
 
 
-def make_img2img_handler(model_choice, pipes):
-    """Return handler for img2img generation."""
+# Handler factories wired to Gradio
 
-    def handler(input_image, prompt, negative, strength, steps, guidance, seed):
-        return _img2img_handler(
-            model_choice,
+
+def make_txt2img_handler(pipes: dict[str, Any]):
+    """Factory to build the txt2img handler with extra UI inputs."""
+
+    def handler(
+        prompt: str,
+        negative: str,
+        steps: int,
+        guidance: float,
+        width: int,
+        height: int,
+        seed: Any,
+        model_choice_value: Any,
+        lora_a_value: Any,
+        lora_a_alpha_value: Any,
+        lora_b_value: Any,
+        lora_b_alpha_value: Any,
+    ):
+        model = str(model_choice_value)
+        return _txt2img_handler(
+            model,
             pipes,
-            input_image,
             prompt,
             negative,
-            strength,
             steps,
             guidance,
+            width,
+            height,
             seed,
+            lora_a_value,
+            lora_a_alpha_value,
+            lora_b_value,
+            lora_b_alpha_value,
         )
 
     return handler
 
 
-def make_txt2img_handler(model_choice, pipes):
-    """Return handler for txt2img generation."""
-
-    def handler(prompt, negative, steps, guidance, width, height, seed):
-        return _txt2img_handler(
-            model_choice,
+def make_img2img_handler(pipes: dict[str, Any]):
+    """Factory to build the img2img handler with extra UI inputs."""
+
+    def handler(
+        input_image: Any,
+        prompt: str,
+        negative: str,
+        strength: float,
+        steps: int,
+        guidance: float,
+        seed: Any,
+        model_choice_value: Any,
+        lora_a_value: Any,
+        lora_a_alpha_value: Any,
+        lora_b_value: Any,
+        lora_b_alpha_value: Any,
+    ):
+        model = str(model_choice_value)
+        return _img2img_handler(
+            model,
             pipes,
+            input_image,
             prompt,
             negative,
+            strength,
             steps,
             guidance,
-            width,
-            height,
             seed,
+            lora_a_value,
+            lora_a_alpha_value,
+            lora_b_value,
+            lora_b_alpha_value,
         )
 
     return handler
 
 
+# Top-level UI composition
+
+
 def build_ui(txt2img_pipes: dict, img2img_pipes: dict) -> gr.Blocks:
     """Build the entire Gradio UI."""
     with gr.Blocks() as demo:
         gr.Markdown(
             "# Stable Diffusion Generator\n"
-            "Generation can take from few seconds to several minutes based \
-on the Model selceted and applied settings."
+            "SD1.5 - slower, higher quality | Turbo - faster, lower quality"
         )
 
         model_choice = gr.Dropdown(
-            choices=[
-                "SD1.5",
-                "Turbo",
-            ],
+            choices=["SD1.5", "Turbo"],
             value="SD1.5",
             label="Model",
         )
-        gr.Markdown(
-            "Use Turbo model if you prefer speed over quality. \
-SD1.5 produces much better results but takes 10 minutes on average \
-for generation on HF Spaces."
-        )
 
+        # LoRA controls (SD1.5 only). Hidden when Turbo is selected.
+        with gr.Accordion("LoRA", open=False) as lora_group:
+            lora_files = list_loras()
+            lora_choices = ["(none)"] + lora_files
+
+            lora_a = gr.Dropdown(
+                lora_choices,
+                value="(none)",
+                label="LoRA A",
+                info=(
+                    "Primary LoRA. Use this for style/character/detail control. "
+                    "Pick '(none)' to disable."
+                ),
+            )
+            alpha_a = gr.Slider(
+                minimum=-2.0,
+                maximum=2.0,
+                value=1.0,
+                step=0.1,
+                label="LoRA A weight",
+                info=(
+                    "Positive → apply effect. Negative → \
+dampen or invert. 0 → disable."
+                ),
+            )
+
+            lora_b = gr.Dropdown(
+                lora_choices,
+                value="(none)",
+                label="LoRA B (optional)",
+                info="Optional second LoRA. Can be mixed with LoRA A.",
+            )
+            alpha_b = gr.Slider(
+                minimum=-2.0,
+                maximum=2.0,
+                value=0.8,
+                step=0.1,
+                label="LoRA B weight",
+                info=("Same convention as LoRA A. Use lighter weights when mixing."),
+            )
+
+        # Core tabs
         txt_controls = build_txt2img_tab(
-            make_txt2img_handler(model_choice.value, txt2img_pipes),
+            make_txt2img_handler(txt2img_pipes),
+            extra_inputs=[model_choice, lora_a, alpha_a, lora_b, alpha_b],
         )
 
         img_controls = build_img2img_tab(
-            make_img2img_handler(model_choice.value, img2img_pipes),
-        )
-
-        build_upscaler_tab(
-            handler=_upscale_handler,
+            make_img2img_handler(img2img_pipes),
+            extra_inputs=[model_choice, lora_a, alpha_a, lora_b, alpha_b],
         )
 
+        build_upscaler_tab(handler=_upscale_handler)
         build_presets_tab(
             txt_controls=txt_controls,
             img_controls=img_controls,
+            model_choice=model_choice,
+            lora_a=lora_a,
+            alpha_a=alpha_a,
+            lora_b=lora_b,
+            alpha_b=alpha_b,
         )
-
         build_history_tab()
 
         model_choice.change(
-            fn=_update_steps_and_cfg,
+            fn=_update_model_dependents,
             inputs=[model_choice],
-            outputs=[txt_controls.steps, txt_controls.guidance],
-        )
-        model_choice.change(
-            fn=_update_steps_and_cfg,
-            inputs=[model_choice],
-            outputs=[img_controls.steps, img_controls.guidance],
+            outputs=[
+                txt_controls.steps,
+                txt_controls.guidance,
+                img_controls.steps,
+                img_controls.guidance,
+                lora_group,
+            ],
         )
 
+        # turbo constraints
+        msg = gr.Markdown("", visible=False)
+        for inp in [model_choice, img_controls.steps, img_controls.strength]:
+            inp.change(
+                fn=_validate_turbo_strength,
+                inputs=[model_choice, img_controls.steps, img_controls.strength],
+                outputs=[img_controls.steps, img_controls.strength, msg],
+            )
+
         gr.Markdown(
             "### Notes\n"
-            "- Use **History → Refresh** if new entries do not appear.\n"
-            "- Presets apply to both **Text → Image** and \
-**Image → Image** tabs.\n"
-            "- This app is hosted on CPU based HF Spaces, so generation may \
-take some time, please be patient.\n"
+            "- **History → Refresh** if new entries do not appear.\n"
+            "- Presets apply to both **Text → Image** and **Image → Image** tabs.\n"
+            "- Deployed on CPU-only HF Spaces, so performance would be a little slower \
+(~10 mins for SD1.5 and ~1.5 min for Turbo on default settings)."
         )
 
     return demo

src/sdgen/ui/tabs/img2img_tab.py

@@ -3,7 +3,7 @@
 from __future__ import annotations
 
 from dataclasses import dataclass
-from typing import Any, Callable, Tuple
+from typing import Any, Callable, List, Optional, Tuple
 
 import gradio as gr
 
@@ -21,16 +21,11 @@ class Img2ImgControls:
     seed: gr.Textbox
 
 
-def build_img2img_tab(handler: Callable[..., Tuple[Any, dict]]) -> Img2ImgControls:
-    """Build the Image → Image tab and connect it to the provided handler.
-
-    Args:
-        handler: A callable accepting the UI inputs and returning:
-            (output_image, metadata_dict)
-
-    Returns:
-        Img2ImgControls: A container with references to UI components.
-    """
+def build_img2img_tab(
+    handler: Callable[..., Tuple[Any, dict]],
+    extra_inputs: Optional[List[gr.components.Component]] = None,
+) -> Img2ImgControls:
+    """Build the Image → Image tab and connect it to the provided handler."""
     with gr.Tab("Image → Image"):
         with gr.Row():
             with gr.Column():
@@ -88,7 +83,7 @@ the prompt more strictly. "
                     value="",
                     placeholder="Leave empty for random",
                 )
-                gr.Markdown("If using Turbo model, ensure steps * strength >= 1")
+
                 generate_button = gr.Button("Generate")
 
             with gr.Column():
@@ -100,17 +95,13 @@ the prompt more strictly. "
                     label="Metadata",
                 )
 
+        inputs = [input_image, prompt, negative, strength, steps, guidance, seed]
+        if extra_inputs:
+            inputs.extend(extra_inputs)
+
         generate_button.click(
             fn=handler,
-            inputs=[
-                input_image,
-                prompt,
-                negative,
-                strength,
-                steps,
-                guidance,
-                seed,
-            ],
+            inputs=inputs,
             outputs=[out_image, out_metadata],
         )
 

src/sdgen/ui/tabs/presets_tab.py

@@ -11,16 +11,19 @@ from sdgen.ui.tabs.img2img_tab import Img2ImgControls
 from sdgen.ui.tabs.txt2img_tab import Txt2ImgControls
 
 
-def apply_preset(preset_name: Any) -> Tuple[Any, ...]:
-    """Return values to populate txt2img and img2img controls.
+def apply_preset(
+    preset_name: Any,
+    model_name: Any,
+) -> Tuple[Any, ...]:
+    """Return values for txt2img and img2img controls based on the chosen preset.
 
     Args:
         preset_name: A string or a one-element list representing the preset key.
+        model_name: The current model choice, used to disable LoRA when Turbo.
 
     Returns:
-        A tuple with values mapped to Text→Image and Image→Image UI controls.
+        Tuple of UI values in a fixed field order.
     """
-    # unwrap dropdown list behavior
     if isinstance(preset_name, (list, tuple)):
         preset_name = preset_name[0] if preset_name else None
 
@@ -31,19 +34,51 @@ def apply_preset(preset_name: Any) -> Tuple[Any, ...]:
     if preset is None:
         raise gr.Error("Invalid preset selected.")
 
+    model = str(model_name).strip()
+
     prompt = preset.get("prompt", "")
     negative = preset.get("negative_prompt", "")
+    steps = int(preset.get("steps", 20))
+    cfg = float(preset.get("cfg", 5.0))
+    width = int(preset.get("width", 512))
+    height = int(preset.get("height", 512))
+    loraA = preset.get("lora_A")
+    alphaA = preset.get("alpha_A", 0.0)
+    loraB = preset.get("lora_B")
+    alphaB = preset.get("alpha_B", 0.0)
+
+    # Turbo mode → ignore LoRA and override sampler settings
+    if model == "Turbo":
+        steps = 2
+        cfg = 0.0
+        loraA = "(none)"
+        alphaA = 0.0
+        loraB = "(none)"
+        alphaB = 0.0
+    else:
+        # normalize empty
+        loraA = loraA or "(none)"
+        loraB = loraB or "(none)"
 
-    # only return data; UI wiring chooses what to set
     status_msg = f"Applied preset: {preset_name}"
 
     return (
         # txt2img
         prompt,
         negative,
+        steps,
+        cfg,
+        width,
+        height,
+        loraA,
+        alphaA,
+        loraB,
+        alphaB,
         # img2img
         prompt,
         negative,
+        steps,
+        cfg,
         # status
         status_msg,
     )
@@ -52,13 +87,13 @@ def apply_preset(preset_name: Any) -> Tuple[Any, ...]:
 def build_presets_tab(
     txt_controls: Txt2ImgControls,
     img_controls: Img2ImgControls,
+    model_choice: gr.Dropdown,
+    lora_a: gr.Dropdown,
+    alpha_a: gr.Slider,
+    lora_b: gr.Dropdown,
+    alpha_b: gr.Slider,
 ) -> None:
-    """Construct the Presets tab and link values to both txt2img and img2img controls.
-
-    Args:
-        txt_controls: References to Text→Image input controls.
-        img_controls: References to Image→Image input controls.
-    """
+    """Create the Presets tab and connect values to UI fields."""
     with gr.Tab("Presets"):
         with gr.Row():
             with gr.Column():
@@ -69,24 +104,27 @@ def build_presets_tab(
                 apply_button = gr.Button("Apply Preset")
                 status_box = gr.Markdown("")
 
-            with gr.Column():
-                gr.Markdown(
-                    "Applying a preset fills prompt, negative prompt, steps, "
-                    "guidance, and resolution for both **Text → Image** "
-                    "and **Image → Image** tabs.",
-                )
-
         apply_button.click(
             fn=apply_preset,
-            inputs=[preset_name],
+            inputs=[preset_name, model_choice],
             outputs=[
                 # txt2img
                 txt_controls.prompt,
                 txt_controls.negative,
+                txt_controls.steps,
+                txt_controls.guidance,
+                txt_controls.width,
+                txt_controls.height,
+                lora_a,
+                alpha_a,
+                lora_b,
+                alpha_b,
                 # img2img
                 img_controls.prompt,
                 img_controls.negative,
-                # status markdown
+                img_controls.steps,
+                img_controls.guidance,
+                # status box
                 status_box,
             ],
         )

src/sdgen/ui/tabs/txt2img_tab.py

@@ -3,7 +3,7 @@
 from __future__ import annotations
 
 from dataclasses import dataclass
-from typing import Callable, Tuple
+from typing import Callable, List, Optional, Tuple
 
 import gradio as gr
 
@@ -24,15 +24,11 @@ class Txt2ImgControls:
     seed: gr.components.Textbox
 
 
-def build_txt2img_tab(handler: Callable[..., Tuple]) -> Txt2ImgControls:
-    """Construct the Text → Image tab and bind the Generate button.
-
-    Args:
-        handler: Function that performs txt2img and returns (image, metadata).
-
-    Returns:
-        A Txt2ImgControls instance containing references to all UI controls.
-    """
+def build_txt2img_tab(
+    handler: Callable[..., Tuple],
+    extra_inputs: Optional[List[gr.components.Component]] = None,
+) -> Txt2ImgControls:
+    """Construct the Text → Image tab and bind the Generate button."""
     with gr.Tab("Text → Image"):
         with gr.Row():
             with gr.Column():
@@ -95,9 +91,12 @@ the prompt more strictly. "
                 out_image = gr.Image(label="Output")
                 out_meta = gr.JSON(label="Metadata (JSON)")
 
+        inputs = [prompt, negative, steps, guidance, width, height, seed]
+        if extra_inputs:
+            inputs.extend(extra_inputs)
         generate_button.click(
             fn=handler,
-            inputs=[prompt, negative, steps, guidance, width, height, seed],
+            inputs=inputs,
             outputs=[out_image, out_meta],
         )
 

src/sdgen/upscaler/__init__.py

@@ -1 +0,0 @@
-"""Package initialization file for Stable Diffusion Image Generator."""