Hello World !

Random Image as a Service — a FastAPI + Gradio server that streams procedurally generated PNG gradients and emoji art on every GET /image request. Nine styles, pool-backed ~1ms responses, and a self-waking embed for Hugging Face Spaces.

.gitignore

@@ -0,0 +1,73 @@
+# Python
+__pycache__/
+*.py[cod]
+*.pyo
+*.pyd
+*.so
+*.egg
+*.egg-info/
+dist/
+build/
+wheels/
+*.whl
+.eggs/
+pip-wheel-metadata/
+
+# Virtual environments
+.venv/
+venv/
+env/
+ENV/
+.env
+
+# Distribution / packaging
+sdist/
+var/
+lib/
+lib64/
+
+# Unit test / coverage
+.tox/
+.coverage
+.coverage.*
+.cache
+.pytest_cache/
+htmlcov/
+nosetests.xml
+coverage.xml
+*.cover
+
+# IDE
+.vscode/
+.idea/
+*.swp
+*.swo
+*~
+
+# macOS
+.DS_Store
+.AppleDouble
+.LSOverride
+
+# Windows
+Thumbs.db
+ehthumbs.db
+Desktop.ini
+
+# Gradio
+gradio_cached_examples/
+flagged/
+
+# HuggingFace Spaces
+.space_history/
+
+# Claude Code
+CLAUDE.md
+
+# Output artefacts
+output/
+*.png
+*.jpg
+*.jpeg
+*.gif
+*.webp

README.md

@@ -0,0 +1,227 @@
+<img src="banner.svg" alt="Random Image as a Service" width="100%">
+
+Point an `<img>` tag at it and get a gradient. Different every time, or pinned with a seed.
+
+Nine styles: linear fades, radial blends, multi-stop color fields, freeform blobs, glassmorphism, banded ramps, low-poly geometry, and emoji — single or tiled in a hexagonal honeycomb.
+
+---
+
+## HTML
+
+```html
+<img src="https://aakkaasshh-random-image-as-a-service.hf.space/image" alt="">
+```
+
+That's the whole thing. Add parameters to control what you get:
+
+> **Hugging Face free-tier Spaces go to sleep after 48 h of inactivity.** Any HTTP request wakes the Space, but HF's proxy handles the first ~30–60 s of boot itself — your `<img>` gets an HTML "waking up" page instead of a PNG. Use the self-waking embed below to handle this automatically.
+
+```html
+<!-- pick a size -->
+<img src="https://aakkaasshh-random-image-as-a-service.hf.space/image?width=1200&height=630">
+
+<!-- pick a style -->
+<img src="https://aakkaasshh-random-image-as-a-service.hf.space/image?style=geometric">
+
+<!-- pin it — same seed always returns the same image -->
+<img src="https://aakkaasshh-random-image-as-a-service.hf.space/image?style=emoji&seed=42">
+```
+
+As a CSS background:
+
+```css
+.hero {
+  background-image: url("https://aakkaasshh-random-image-as-a-service.hf.space/image?width=1920&height=1080&style=shape_blur");
+  background-size: cover;
+}
+```
+
+In Markdown:
+
+```markdown
+![](https://aakkaasshh-random-image-as-a-service.hf.space/image?width=800&height=200&style=gradient_ramp)
+```
+
+As an OG image:
+
+```html
+<meta property="og:image" content="https://aakkaasshh-random-image-as-a-service.hf.space/image?width=1200&height=630&seed=7">
+```
+
+### Self-waking embed
+
+If the Space might be sleeping, use this instead of a bare `<img>`:
+
+```html
+<img src="https://aakkaasshh-random-image-as-a-service.hf.space/image"
+     onerror="var e=this;setTimeout(function(){e.src=e.dataset.src+'?t='+Date.now()},10000)"
+     data-src="https://aakkaasshh-random-image-as-a-service.hf.space/image"
+     alt="">
+```
+
+How it works:
+- `onerror` fires when the browser gets HF's HTML wake-page instead of a PNG
+- After 10 s it retries with a cache-busting `?t=` param
+- Keeps retrying every 10 s until the Space is awake and returns a real image
+- Once the Space is up the image loads and `onerror` never fires again
+
+To never hit the sleep state at all, point an uptime monitor (UptimeRobot free tier) at `https://aakkaasshh-random-image-as-a-service.hf.space/image` every 5 minutes. Any hit counts as activity to HF, so the Space never goes idle.
+
+---
+
+## API
+
+`GET /image` returns a PNG. All parameters are optional.
+
+| Parameter | Default | Allowed values |
+|---|---|---|
+| `width` | 1024 | 64 – 4096 |
+| `height` | 768 | 64 – 4096 |
+| `style` | random | `linear` `radial` `multicolor` `freeform` `shape_blur` `gradient_ramp` `geometric` `emoji` `emoji_hex` |
+| `seed` | random | any integer |
+
+Bad dimensions return HTTP 400 with a JSON error body. Everything else is a PNG byte stream.
+
+### Speed
+
+When hosted on Hugging Face Spaces (or run locally via `python app.py`), the Gradio server pre-generates a pool of 50 images at startup. Bare requests with no parameters are served from that pool — **~1ms turnaround**, no generation overhead:
+
+```
+GET /image               → pool hit  (X-RIaaS-Source: pool)  ~1ms
+GET /image?style=linear  → generated (X-RIaaS-Source: live)  ~50–200ms
+```
+
+The pool builds in the background; during the first ~15 seconds the server falls through to live generation automatically.
+
+### curl
+
+```bash
+# save one
+curl "https://aakkaasshh-random-image-as-a-service.hf.space/image?style=geometric&width=800&height=600" -o banner.png
+
+# batch — 20 different seeds
+for i in $(seq 1 20); do
+  curl "https://aakkaasshh-random-image-as-a-service.hf.space/image?seed=$i" -o "img_$i.png"
+done
+```
+
+### Python
+
+```python
+import io, urllib.request
+from PIL import Image
+
+with urllib.request.urlopen("https://aakkaasshh-random-image-as-a-service.hf.space/image?style=emoji_hex&seed=9") as r:
+    img = Image.open(io.BytesIO(r.read()))
+
+img.save("out.png")
+```
+
+Interactive docs at `/docs` (Swagger) and `/redoc`.
+
+---
+
+## Gradio
+
+The Gradio UI is at `https://aakkaasshh-random-image-as-a-service.hf.space/` (or `http://localhost:7860` locally). Sliders for width and height, a style dropdown, a seed box, and a live preview.
+
+Gradio also exposes its own inference API on the same server:
+
+```bash
+curl -X POST "https://aakkaasshh-random-image-as-a-service.hf.space/run/generate_image" \
+  -H "Content-Type: application/json" \
+  -d '{"data": [800, 600, "geometric", "42"]}'
+```
+
+The four values in `data` are width, height, style, and seed. Pass `""` for a random seed.
+
+Or use `gradio_client`:
+
+```python
+from gradio_client import Client
+
+client = Client("https://aakkaasshh-random-image-as-a-service.hf.space")
+image_path, info = client.predict(
+    800, 600, "emoji_hex", "",
+    api_name="/generate_image",
+)
+# image_path is a local temp file
+# info is "Style: emoji_hex | Seed: 1837492"
+```
+
+---
+
+## Running locally
+
+```bash
+git clone https://github.com/AkashSCIENTIST/Random-Image-as-a-Service
+cd Random-Image-as-a-Service
+pip install -r requirements.txt
+```
+
+**Gradio + API server** (one command gives you both the UI and `GET /image`):
+
+```bash
+python app.py
+# UI  → http://localhost:7860
+# API → http://localhost:7860/image
+```
+
+Or with uvicorn for production:
+
+```bash
+uvicorn app:app --host 0.0.0.0 --port 7860
+```
+
+**FastAPI-only server** (lighter, no UI):
+
+```bash
+uvicorn api:app --reload
+# http://localhost:8000/image
+```
+
+**Without a server** — call the generator directly:
+
+```python
+from core.service import generate
+
+img, meta = generate(width=1024, height=768, style="emoji_hex", seed=42)
+img.save("out.png")
+print(meta)
+# {'style': 'emoji_hex', 'width': 1024, 'height': 768, 'seed': 42, 'params': {...}}
+```
+
+**Deploy to Hugging Face Spaces** — create a Space with SDK: Gradio, then:
+
+```bash
+git remote add space https://huggingface.co/spaces/aakkaasshh/Random-Image-as-a-Service
+git push space main
+```
+
+Spaces detects the FastAPI `app` object in `app.py` and serves it with uvicorn. You get the Gradio UI at `/` and `GET /image` on the same URL — pool-backed, ~1ms after warmup.
+
+---
+
+## Styles
+
+| Name | Description |
+|---|---|
+| `linear` | Two colors fading at any angle |
+| `radial` | Circular fade from center |
+| `multicolor` | 3–5 color stops, linear or radial |
+| `freeform` | Two colors blended through scattered control points |
+| `shape_blur` | Blurred translucent blobs on a light base |
+| `gradient_ramp` | Gradient cut into hard color bands |
+| `geometric` | Low-poly triangles in a coordinated palette |
+| `emoji` | Single emoji on a plain background with a soft oval shadow |
+| `emoji_hex` | Two emojis tiled on a honeycomb lattice — each surrounded entirely by the other |
+
+---
+
+## Adding a style
+
+1. Add `styles/my_style.py` — extend `GradientStyle`, implement `render()`, add `random_params()`.
+2. Register it in `core/registry.py`.
+3. Add the name to `VALID_STYLES` in `core/config.py`.
+
+It shows up in the API, the Gradio dropdown, and `generate()` automatically.

api.py

@@ -0,0 +1,23 @@
+import io
+from fastapi import FastAPI, Query, Response, HTTPException
+from core import service, config
+
+app = FastAPI(title="RIaaS — Random Image as a Service")
+
+
+@app.get("/image")
+def get_image(
+    width: int = Query(config.DEFAULT_WIDTH, ge=config.MIN_WIDTH, le=config.MAX_WIDTH),
+    height: int = Query(config.DEFAULT_HEIGHT, ge=config.MIN_HEIGHT, le=config.MAX_HEIGHT),
+    style: str = Query(None),
+    seed: int = Query(None),
+) -> Response:
+    try:
+        image, meta = service.generate(width, height, style, seed)
+    except ValueError as exc:
+        raise HTTPException(status_code=400, detail=str(exc))
+
+    buf = io.BytesIO()
+    image.save(buf, format="PNG")
+    buf.seek(0)
+    return Response(content=buf.read(), media_type="image/png")

app.py

@@ -0,0 +1,110 @@
+import io
+import random
+import threading
+
+import gradio as gr
+from fastapi import FastAPI, HTTPException, Query
+from fastapi.responses import Response
+from PIL import Image
+
+from core import config, service
+
+# ── Pre-generated image pool ──────────────────────────────────────────────────
+# Images are rendered once at startup and kept as PNG bytes in memory.
+# GET /image with no params picks one at random: memory lookup + HTTP write ≈ 1ms.
+POOL_SIZE = 50
+_pool: list[bytes] = []
+
+
+def _build_pool() -> None:
+    # Append one-by-one so the pool is usable after the very first image (~200ms),
+    # not only after all 50 are done. Critical for cold-start / post-sleep behaviour.
+    for _ in range(POOL_SIZE):
+        img, _ = service.generate(config.DEFAULT_WIDTH, config.DEFAULT_HEIGHT, None, None)
+        buf = io.BytesIO()
+        img.save(buf, "PNG", compress_level=1)
+        _pool.append(buf.getvalue())
+
+
+threading.Thread(target=_build_pool, daemon=True).start()
+
+
+# ── FastAPI app ───────────────────────────────────────────────────────────────
+app = FastAPI(title="RIaaS — Random Image as a Service")
+
+
+@app.get("/image")
+async def image_api(
+    width:  int | None = Query(None, ge=config.MIN_WIDTH,  le=config.MAX_WIDTH),
+    height: int | None = Query(None, ge=config.MIN_HEIGHT, le=config.MAX_HEIGHT),
+    style:  str | None = Query(None),
+    seed:   int | None = Query(None),
+):
+    # Default request (no params) → serve from pool; ~1ms once pool is warm.
+    # While pool is still building the first time, fall through to live generation.
+    if _pool and width is None and height is None and style is None and seed is None:
+        return Response(
+            content=random.choice(_pool),
+            media_type="image/png",
+            headers={"X-RIaaS-Source": "pool"},
+        )
+
+    # Custom params → generate on demand
+    try:
+        img, _ = service.generate(
+            width  or config.DEFAULT_WIDTH,
+            height or config.DEFAULT_HEIGHT,
+            style  or "random",
+            seed,
+        )
+    except ValueError as exc:
+        raise HTTPException(status_code=400, detail=str(exc))
+
+    buf = io.BytesIO()
+    img.save(buf, "PNG", compress_level=1)
+    return Response(
+        content=buf.getvalue(),
+        media_type="image/png",
+        headers={"X-RIaaS-Source": "live"},
+    )
+
+
+# ── Gradio UI ─────────────────────────────────────────────────────────────────
+STYLE_CHOICES = ["random"] + config.VALID_STYLES
+
+
+def generate_image(width: int, height: int, style: str, seed: str) -> tuple[Image.Image, str]:
+    parsed_seed = int(seed) if seed.strip() else None
+    try:
+        image, meta = service.generate(int(width), int(height), style, parsed_seed)
+    except ValueError as exc:
+        return None, str(exc)
+    return image, f"Style: {meta['style']} | Seed: {meta['seed']}"
+
+
+with gr.Blocks(title="RIaaS — Random Image as a Service") as demo:
+    gr.Markdown("# Random Image as a Service\nGenerate beautiful gradient images on demand.")
+    with gr.Row():
+        with gr.Column(scale=1):
+            width_slider   = gr.Slider(config.MIN_WIDTH,  config.MAX_WIDTH,  value=config.DEFAULT_WIDTH,  step=8, label="Width")
+            height_slider  = gr.Slider(config.MIN_HEIGHT, config.MAX_HEIGHT, value=config.DEFAULT_HEIGHT, step=8, label="Height")
+            style_dropdown = gr.Dropdown(STYLE_CHOICES, value="random", label="Style")
+            seed_input     = gr.Textbox(value="", placeholder="Leave blank for random", label="Seed")
+            generate_btn   = gr.Button("Generate", variant="primary")
+        with gr.Column(scale=2):
+            output_image = gr.Image(label="Result", type="pil")
+            output_info  = gr.Textbox(label="Info", interactive=False)
+
+    generate_btn.click(
+        generate_image,
+        inputs=[width_slider, height_slider, style_dropdown, seed_input],
+        outputs=[output_image, output_info],
+    )
+
+# Mount Gradio at root. Routes defined on `app` above (/image) are matched
+# before the wildcard Gradio mount, so both coexist without conflict.
+app = gr.mount_gradio_app(app, demo, path="/")
+
+if __name__ == "__main__":
+    import uvicorn
+    uvicorn.run(app, host="0.0.0.0", port=7860)

core/base.py

@@ -0,0 +1,12 @@
+from abc import ABC, abstractmethod
+from PIL import Image
+
+
+class GradientStyle(ABC):
+    def __init__(self, width: int, height: int):
+        self.width = width
+        self.height = height
+
+    @abstractmethod
+    def render(self) -> Image.Image:
+        ...

core/color_utils.py

@@ -0,0 +1,63 @@
+import random
+import colorsys
+
+
+def random_hex_color(rng: random.Random) -> str:
+    r, g, b = (rng.randint(0, 255) for _ in range(3))
+    return f"#{r:02x}{g:02x}{b:02x}"
+
+
+def _hex_to_rgb(hex_color: str) -> tuple[float, float, float]:
+    h = hex_color.lstrip("#")
+    return tuple(int(h[i:i+2], 16) / 255.0 for i in (0, 2, 4))
+
+
+def _rgb_to_hex(r: float, g: float, b: float) -> str:
+    return "#{:02x}{:02x}{:02x}".format(int(r * 255), int(g * 255), int(b * 255))
+
+
+def complementary(hex_color: str) -> str:
+    r, g, b = _hex_to_rgb(hex_color)
+    h, s, v = colorsys.rgb_to_hsv(r, g, b)
+    h = (h + 0.5) % 1.0
+    return _rgb_to_hex(*colorsys.hsv_to_rgb(h, max(s, 0.65), max(v, 0.75)))
+
+
+def analogous(hex_color: str, n: int = 2, spread_deg: float = 30.0) -> list[str]:
+    r, g, b = _hex_to_rgb(hex_color)
+    h, s, v = colorsys.rgb_to_hsv(r, g, b)
+    spread = spread_deg / 360.0
+    step = spread / max(n - 1, 1)
+    start = h - spread / 2
+    return [_rgb_to_hex(*colorsys.hsv_to_rgb((start + i * step) % 1.0, s, v)) for i in range(n)]
+
+
+def vibrant_analogous(rng: random.Random, n: int, spread_deg: float = 50.0) -> list[str]:
+    """Analogous palette with forced vibrancy and alternating lightness for differentiability."""
+    base_h = rng.random()
+    base_s = rng.uniform(0.60, 0.88)
+    base_v = rng.uniform(0.72, 0.94)
+    spread = spread_deg / 360.0
+    step = spread / max(n - 1, 1)
+    start = base_h - spread / 2
+    colors = []
+    for i in range(n):
+        hue = (start + i * step) % 1.0
+        # Alternate value high/low so adjacent colors are clearly distinct
+        v = base_v - 0.18 if i % 2 == 1 else base_v
+        s = min(0.95, base_s + 0.08) if i % 2 == 1 else base_s
+        colors.append(_rgb_to_hex(*colorsys.hsv_to_rgb(hue, s, max(0.55, v))))
+    return colors
+
+
+def random_palette(rng: random.Random, n: int, scheme: str = "random") -> list[str]:
+    base = random_hex_color(rng)
+    if scheme == "complementary":
+        r, g, b = _hex_to_rgb(base)
+        h, s, v = colorsys.rgb_to_hsv(r, g, b)
+        # Force both colors to be vibrant
+        base = _rgb_to_hex(*colorsys.hsv_to_rgb(h, max(s, 0.65), max(v, 0.72)))
+        return [base, complementary(base)][:n]
+    if scheme == "analogous":
+        return vibrant_analogous(rng, n, spread_deg=rng.uniform(30, 60))
+    return [random_hex_color(rng) for _ in range(n)]

core/config.py

@@ -0,0 +1,20 @@
+MIN_WIDTH = 64
+MAX_WIDTH = 4096
+MIN_HEIGHT = 64
+MAX_HEIGHT = 4096
+
+DEFAULT_WIDTH = 1024
+DEFAULT_HEIGHT = 768
+DEFAULT_SEED = None
+
+VALID_STYLES = [
+    "linear",
+    "radial",
+    "multicolor",
+    "freeform",
+    "shape_blur",
+    "gradient_ramp",
+    "geometric",
+    "emoji",
+    "emoji_hex",
+]

core/registry.py

@@ -0,0 +1,30 @@
+import random
+from styles import linear, radial, multicolor, freeform, shape_blur, gradient_ramp, geometric, emoji, emoji_hex
+
+STYLE_TABLE: dict[str, dict] = {
+    "linear":        {"cls": linear.LinearGradient,           "params": linear.random_params},
+    "radial":        {"cls": radial.RadialGradient,           "params": radial.random_params},
+    "multicolor":    {"cls": multicolor.MulticolorGradient,   "params": multicolor.random_params},
+    "freeform":      {"cls": freeform.FreeformGradient,       "params": freeform.random_params},
+    "shape_blur":    {"cls": shape_blur.ShapeBlurGradient,    "params": shape_blur.random_params},
+    "gradient_ramp": {"cls": gradient_ramp.GradientRampStyle, "params": gradient_ramp.random_params},
+    "geometric":     {"cls": geometric.GeometricStyle,        "params": geometric.random_params},
+    "emoji":         {"cls": emoji.EmojiStyle,                "params": emoji.random_params},
+    "emoji_hex":     {"cls": emoji_hex.EmojiHexStyle,         "params": emoji_hex.random_params},
+}
+
+
+def pick_random_style(
+    width: int,
+    height: int,
+    style_name: str = None,
+    seed: int = None,
+) -> tuple:
+    rng = random.Random(seed)
+    if style_name is None or style_name not in STYLE_TABLE:
+        style_name = rng.choice(list(STYLE_TABLE.keys()))
+
+    entry = STYLE_TABLE[style_name]
+    params = entry["params"](width, height, rng)
+    instance = entry["cls"](width=width, height=height, **params)
+    return instance, style_name, params

core/service.py

@@ -0,0 +1,21 @@
+from PIL import Image
+from . import config, registry
+
+
+def generate(
+    width: int,
+    height: int,
+    style: str = None,
+    seed: int = None,
+) -> tuple[Image.Image, dict]:
+    if not (config.MIN_WIDTH <= width <= config.MAX_WIDTH):
+        raise ValueError(f"width must be between {config.MIN_WIDTH} and {config.MAX_WIDTH}")
+    if not (config.MIN_HEIGHT <= height <= config.MAX_HEIGHT):
+        raise ValueError(f"height must be between {config.MIN_HEIGHT} and {config.MAX_HEIGHT}")
+
+    style_arg = None if style in (None, "random") else style
+    instance, chosen_style, params = registry.pick_random_style(width, height, style_arg, seed)
+    image = instance.render()
+
+    meta = {"style": chosen_style, "width": width, "height": height, "seed": seed, "params": params}
+    return image, meta

requirements.txt

@@ -0,0 +1,5 @@
+pillow
+numpy
+fastapi
+uvicorn
+gradio

styles/duotone.py

@@ -0,0 +1,65 @@
+import random
+import colorsys
+import numpy as np
+from PIL import Image, ImageFilter
+from core.base import GradientStyle
+
+
+def _hex_to_rgb(hex_color: str) -> tuple[int, int, int]:
+    h = hex_color.lstrip("#")
+    return tuple(int(h[i:i+2], 16) for i in (0, 2, 4))
+
+
+def _hsv_to_hex(h: float, s: float, v: float) -> str:
+    r, g, b = colorsys.hsv_to_rgb(h, s, v)
+    return "#{:02x}{:02x}{:02x}".format(int(r * 255), int(g * 255), int(b * 255))
+
+
+class DuotoneGradient(GradientStyle):
+    def __init__(
+        self,
+        width: int,
+        height: int,
+        shadow_color: str,
+        highlight_color: str,
+        noise_seed: int = None,
+    ):
+        super().__init__(width, height)
+        self.shadow_color = shadow_color
+        self.highlight_color = highlight_color
+        self.noise_seed = noise_seed
+
+    def render(self) -> Image.Image:
+        rng = np.random.default_rng(self.noise_seed)
+
+        # Multi-scale noise gives a more organic, interesting luminance base
+        lum = np.zeros((self.height, self.width), dtype=np.float32)
+        for scale in [4, 8, 16]:
+            th, tw = max(2, self.height // scale), max(2, self.width // scale)
+            layer = rng.random((th, tw)).astype(np.float32)
+            layer_img = Image.fromarray((layer * 255).astype(np.uint8), "L")
+            layer_img = layer_img.resize((self.width, self.height), Image.BILINEAR)
+            layer_img = layer_img.filter(ImageFilter.GaussianBlur(radius=max(2, min(self.width, self.height) // (scale * 2))))
+            lum += np.array(layer_img, dtype=np.float32) / 255.0
+        lum /= 3.0
+        # Boost contrast so midtones don't dominate
+        lum = np.clip((lum - 0.5) * 1.5 + 0.5, 0, 1)
+
+        shadow = np.array(_hex_to_rgb(self.shadow_color), dtype=np.float32)
+        highlight = np.array(_hex_to_rgb(self.highlight_color), dtype=np.float32)
+        img_arr = (shadow * (1 - lum[..., None]) + highlight * lum[..., None]).astype(np.uint8)
+        return Image.fromarray(img_arr, "RGB")
+
+
+def random_params(width: int, height: int, rng: random.Random) -> dict:
+    # Shadow: very dark, richly saturated
+    h_shadow = rng.random()
+    shadow = _hsv_to_hex(h_shadow, rng.uniform(0.70, 0.90), rng.uniform(0.08, 0.20))
+    # Highlight: bright, vivid, complementary hue
+    h_highlight = (h_shadow + rng.uniform(0.40, 0.60)) % 1.0
+    highlight = _hsv_to_hex(h_highlight, rng.uniform(0.75, 0.95), rng.uniform(0.88, 1.00))
+    return {
+        "shadow_color": shadow,
+        "highlight_color": highlight,
+        "noise_seed": rng.randint(0, 2 ** 31),
+    }

styles/emoji.py

@@ -0,0 +1,144 @@
+import random
+import colorsys
+from pathlib import Path
+import numpy as np
+from PIL import Image, ImageDraw, ImageFilter, ImageFont
+from core.base import GradientStyle
+
+EMOJI_POOL = [
+    # Nature & weather
+    "🌊", "🔥", "⚡", "🌸", "🌺", "🍀", "🌙", "✨", "🌈", "🍄",
+    "🌻", "🏔️", "🌿", "🌴", "🍁", "🌞", "🌵", "🌾", "🌷", "🌋",
+    "❄️", "🌏", "🏵️", "🌬️", "🌪️", "🌠", "☄️", "⛅", "🌑", "🌊",
+    # Animals
+    "🦋", "🐉", "🦄", "🦅", "🦊", "🦁", "🐯", "🐸", "🦩", "🐬",
+    "🦜", "🦀", "🐙", "🦚", "🪸", "🦭", "🦦", "🦥", "🦘", "🦒",
+    "🐘", "🦏", "🐊", "🦈", "🐋", "🦑", "🦩", "🦢", "🦋", "🐓",
+    # Objects — Accessories & Jewelry
+    "💎", "👑", "🎩", "🕶️", "💍", "🪬", "🧿",
+    # Objects — Music
+    "🎵", "🎶", "🎷", "🎸", "🎺", "🎻", "🥁", "🪗", "🪘", "🎹",
+    # Objects — Light & Optics
+    "📷", "🎬", "📽️", "🔭", "💡", "🔦", "🕯️", "🪔",
+    # Objects — Science
+    "🔬", "⚗️", "🧬", "🧪", "🔮",
+    # Objects — Tools
+    "⚙️", "🔧", "🔩", "⚒️", "🛠️", "🪛", "🧲",
+    # Objects — Games & Sport trophies
+    "🎯", "🎮", "🕹️", "🎲", "🎳", "🎱", "🏆", "🥇", "🎪",
+    "⚽", "🏀", "🎾", "🏈", "⚾", "🏓", "🥊", "🎿",
+    # Objects — Celebration & Misc
+    "🎨", "🎭", "🎁", "🎀", "🎊", "🎉", "🧨", "🪆", "🎠",
+    "🎋", "🪩", "🎆", "🎇", "🎑",
+    # Objects — Food (iconic shapes)
+    "🍉", "🎂", "🍕", "🍦", "🍩", "🍣", "🍭", "🧁",
+    # Objects — Vehicles & Transport (iconic shapes)
+    "🚀", "✈️", "🛸", "🚁", "⛵", "🏎️"
+]
+
+_FONT_CANDIDATES = [
+    "C:/Windows/Fonts/seguiemj.ttf",
+    r"C:\Windows\Fonts\seguiemj.ttf",
+    "/System/Library/Fonts/Apple Color Emoji.ttc",
+    "/usr/share/fonts/truetype/noto/NotoColorEmoji.ttf",
+    "/usr/share/fonts/noto/NotoColorEmoji.ttf",
+    "/usr/share/fonts/google-noto-emoji/NotoColorEmoji.ttf",
+]
+
+
+def _load_emoji_font(size: int) -> ImageFont.FreeTypeFont | None:
+    for path in _FONT_CANDIDATES:
+        if Path(path).exists():
+            try:
+                return ImageFont.truetype(path, size)
+            except Exception:
+                continue
+    return None
+
+
+def _detect_is_light(emoji: str, font: ImageFont.FreeTypeFont) -> bool:
+    """Render emoji on black; bright result → emoji is light-coloured."""
+    probe = Image.new("RGB", (80, 80), (0, 0, 0))
+    d = ImageDraw.Draw(probe)
+    d.text((8, 8), emoji, font=font, embedded_color=True)
+    return np.array(probe, dtype=np.float32).mean() > 145
+
+
+class EmojiStyle(GradientStyle):
+    def __init__(
+        self,
+        width: int,
+        height: int,
+        emoji: str,
+        bg_light: str,
+        bg_dark: str,
+        seed: int = None,
+    ):
+        super().__init__(width, height)
+        self.emoji = emoji
+        self.bg_light = bg_light
+        self.bg_dark = bg_dark
+        self.seed = seed
+
+    def _parse_hex(self, hex_color: str) -> tuple:
+        h = hex_color.lstrip("#")
+        return tuple(int(h[i:i+2], 16) for i in (0, 2, 4))
+
+    def render(self) -> Image.Image:
+        font_size = int(min(self.width, self.height) * 0.52)
+        font = _load_emoji_font(font_size)
+
+        if font is None:
+            return Image.new("RGB", (self.width, self.height), self._parse_hex(self.bg_light))
+
+        probe_font = _load_emoji_font(64)
+        is_light = _detect_is_light(self.emoji, probe_font) if probe_font else False
+        bg = self._parse_hex(self.bg_dark if is_light else self.bg_light)
+
+        canvas = Image.new("RGBA", (self.width, self.height), (*bg, 255))
+
+        # Measure emoji to find centre position
+        m = ImageDraw.Draw(Image.new("RGBA", (1, 1)))
+        bbox = m.textbbox((0, 0), self.emoji, font=font, embedded_color=True)
+        ew, eh = bbox[2] - bbox[0], bbox[3] - bbox[1]
+        # Shift emoji slightly above centre so the shadow shows below it
+        lift = int(min(self.width, self.height) * 0.025)
+        tx = (self.width - ew) // 2 - bbox[0]
+        ty = (self.height - eh) // 2 - bbox[1] - lift
+
+        # Shadow: a soft oval disc directly below the emoji — NOT shape-matched.
+        # This gives a "floating above the surface" look regardless of emoji shape.
+        shadow_r_x = int(min(self.width, self.height) * 0.30)
+        shadow_r_y = int(shadow_r_x * 0.30)
+        shadow_drop = int(min(self.width, self.height) * 0.06)
+        scx = self.width // 2
+        scy = self.height // 2 + lift + shadow_drop
+        shadow = Image.new("RGBA", (self.width, self.height), (0, 0, 0, 0))
+        ImageDraw.Draw(shadow).ellipse(
+            [scx - shadow_r_x, scy - shadow_r_y, scx + shadow_r_x, scy + shadow_r_y],
+            fill=(0, 0, 0, 90),
+        )
+        shadow = shadow.filter(ImageFilter.GaussianBlur(radius=shadow_r_x // 3))
+        canvas = Image.alpha_composite(canvas, shadow)
+
+        # Emoji
+        emoji_layer = Image.new("RGBA", (self.width, self.height), (0, 0, 0, 0))
+        ImageDraw.Draw(emoji_layer).text((tx, ty), self.emoji, font=font, embedded_color=True)
+        canvas = Image.alpha_composite(canvas, emoji_layer)
+
+        return canvas.convert("RGB")
+
+
+def random_params(_width: int, _height: int, rng: random.Random) -> dict:
+    emoji = rng.choice(EMOJI_POOL)
+    h = rng.random()
+    r, g, b = colorsys.hsv_to_rgb(h, rng.uniform(0.06, 0.16), rng.uniform(0.93, 0.99))
+    bg_light = "#{:02x}{:02x}{:02x}".format(int(r * 255), int(g * 255), int(b * 255))
+    r2, g2, b2 = colorsys.hsv_to_rgb((h + 0.5) % 1.0, rng.uniform(0.55, 0.80), rng.uniform(0.08, 0.18))
+    bg_dark = "#{:02x}{:02x}{:02x}".format(int(r2 * 255), int(g2 * 255), int(b2 * 255))
+    return {
+        "emoji": emoji,
+        "bg_light": bg_light,
+        "bg_dark": bg_dark,
+        "seed": rng.randint(0, 2 ** 31),
+    }

styles/emoji_hex.py

@@ -0,0 +1,115 @@
+import math
+import random
+import colorsys
+from PIL import Image, ImageDraw
+from core.base import GradientStyle
+from styles.emoji import EMOJI_POOL, _load_emoji_font
+
+_SQRT3 = math.sqrt(3)
+
+
+class EmojiHexStyle(GradientStyle):
+    """
+    Emojis placed at the vertices of a honeycomb tiling.
+    The honeycomb vertex graph is bipartite: alternate corners of every hexagon
+    belong to sublattice A (emoji_0) and sublattice B (emoji_1), so adjacent
+    vertices are always opposite emojis — exactly the 'alternate corners' pattern.
+    """
+
+    def __init__(
+        self,
+        width: int,
+        height: int,
+        emojis: list[str],   # exactly 2 entries
+        bg_color: str,
+        emoji_size: int,
+        seed: int = None,
+    ):
+        super().__init__(width, height)
+        self.emojis = emojis[:2]
+        self.bg_color = bg_color
+        self.emoji_size = emoji_size
+        self.seed = seed
+
+    def _parse_hex(self, hex_color: str) -> tuple:
+        h = hex_color.lstrip("#")
+        return tuple(int(h[i:i+2], 16) for i in (0, 2, 4))
+
+    def render(self) -> Image.Image:
+        bg = self._parse_hex(self.bg_color)
+        img = Image.new("RGBA", (self.width, self.height), (*bg, 255))
+
+        font = _load_emoji_font(self.emoji_size)
+        if font is None:
+            return img.convert("RGB")
+
+        emo_a, emo_b = self.emojis[0], self.emojis[1]
+        m = ImageDraw.Draw(Image.new("RGBA", (1, 1)))
+        ba = m.textbbox((0, 0), emo_a, font=font, embedded_color=True)
+        bb = m.textbbox((0, 0), emo_b, font=font, embedded_color=True)
+        # Pre-compute draw offset so each emoji is centred on its lattice point
+        oa = (-(ba[2] - ba[0]) // 2 - ba[0], -(ba[3] - ba[1]) // 2 - ba[1])
+        ob = (-(bb[2] - bb[0]) // 2 - bb[0], -(bb[3] - bb[1]) // 2 - bb[1])
+
+        layer = Image.new("RGBA", (self.width, self.height), (0, 0, 0, 0))
+        draw = ImageDraw.Draw(layer)
+
+        # R = circumradius of each hexagonal cell = nearest-neighbour distance
+        # in the honeycomb.  Set > emoji_size so adjacent emojis don't overlap.
+        R = int(self.emoji_size * 1.30)
+
+        # Triangular lattice of hex *centres*:
+        #   a1 = (3R/2,  R√3/2)   a2 = (0, R√3)
+        a1x, a1y = 1.5 * R, 0.5 * R * _SQRT3
+        a2x, a2y = 0.0, R * _SQRT3
+
+        # Vertex offsets from each hex centre.
+        # Even corners (k=0,2,4) → sublattice A  (alternate corners)
+        # Odd  corners (k=1,3,5) → sublattice B  (the other alternate corners)
+        half = R * 0.5
+        h32 = R * _SQRT3 * 0.5
+        offsets_a = [(R, 0.0), (-half,  h32), (-half, -h32)]
+        offsets_b = [(half, h32), (-R, 0.0), (half, -h32)]
+
+        margin = 3
+        pad = self.emoji_size
+        m_max = int(self.width  / a1x) + margin + 2
+        n_max = int(self.height / a2y) + margin + 2
+
+        seen_a: set[tuple[int, int]] = set()
+        seen_b: set[tuple[int, int]] = set()
+
+        for mi in range(-margin, m_max):
+            for ni in range(-margin, n_max):
+                cx = mi * a1x + ni * a2x
+                cy = mi * a1y + ni * a2y
+
+                for offsets, seen, emo, off in (
+                    (offsets_a, seen_a, emo_a, oa),
+                    (offsets_b, seen_b, emo_b, ob),
+                ):
+                    for dx, dy in offsets:
+                        pos = (round(cx + dx), round(cy + dy))
+                        if pos in seen:
+                            continue
+                        seen.add(pos)
+                        px, py = pos
+                        if -pad <= px <= self.width + pad and -pad <= py <= self.height + pad:
+                            draw.text((px + off[0], py + off[1]), emo, font=font, embedded_color=True)
+
+        return Image.alpha_composite(img, layer).convert("RGB")
+
+
+def random_params(_width: int, _height: int, rng: random.Random) -> dict:
+    emojis = rng.sample(EMOJI_POOL, 2)
+    h = rng.random()
+    r, g, b = colorsys.hsv_to_rgb(h, rng.uniform(0.04, 0.12), rng.uniform(0.93, 0.99))
+    bg_color = "#{:02x}{:02x}{:02x}".format(int(r * 255), int(g * 255), int(b * 255))
+    # emoji_size drives both font render size and cell spacing
+    emoji_size = max(48, min(_width, _height) // rng.randint(5, 8))
+    return {
+        "emojis": emojis,
+        "bg_color": bg_color,
+        "emoji_size": emoji_size,
+        "seed": rng.randint(0, 2 ** 31),
+    }

styles/freeform.py

@@ -0,0 +1,50 @@
+import random
+import numpy as np
+from PIL import Image
+from core.base import GradientStyle
+from core import color_utils
+
+
+def _hex_to_rgb(hex_color: str) -> tuple[int, int, int]:
+    h = hex_color.lstrip("#")
+    return tuple(int(h[i:i+2], 16) for i in (0, 2, 4))
+
+
+def _idw_blend(xs: np.ndarray, ys: np.ndarray, points: np.ndarray, colors: np.ndarray, power: float = 2.0) -> np.ndarray:
+    coords = np.stack([xs.ravel(), ys.ravel()], axis=-1).astype(np.float32)
+    diffs = coords[:, None, :] - points[None, :, :]
+    dist2 = (diffs ** 2).sum(axis=-1)
+    dist2 = np.maximum(dist2, 1e-10)
+    weights = 1.0 / dist2 ** (power / 2)
+    weights /= weights.sum(axis=-1, keepdims=True)
+    blended = (weights[:, :, None] * colors[None, :, :]).sum(axis=1)
+    return blended.reshape(*xs.shape, 3).astype(np.uint8)
+
+
+class FreeformGradient(GradientStyle):
+    def __init__(self, width: int, height: int, colors: list[str], num_points: int = 5, seed: int = None):
+        super().__init__(width, height)
+        self.colors = colors
+        self.num_points = num_points
+        self.seed = seed
+
+    def render(self) -> Image.Image:
+        rng = np.random.default_rng(self.seed)
+        px = rng.uniform(0, self.width - 1, self.num_points)
+        py = rng.uniform(0, self.height - 1, self.num_points)
+        points = np.stack([px, py], axis=-1).astype(np.float32)
+
+        rgbs = [_hex_to_rgb(self.colors[i % len(self.colors)]) for i in range(self.num_points)]
+        colors_arr = np.array(rgbs, dtype=np.float32)
+
+        ys, xs = np.mgrid[0:self.height, 0:self.width]
+        img_arr = _idw_blend(xs, ys, points, colors_arr)
+        return Image.fromarray(img_arr, "RGB")
+
+
+def random_params(width: int, height: int, rng: random.Random) -> dict:
+    return {
+        "colors": color_utils.random_palette(rng, 2, scheme="analogous"),
+        "num_points": rng.randint(5, 9),
+        "seed": rng.randint(0, 2 ** 31),
+    }

styles/geometric.py

@@ -0,0 +1,87 @@
+import random
+import numpy as np
+from PIL import Image, ImageDraw
+from core.base import GradientStyle
+from core import color_utils
+
+SUPERSAMPLE = 2
+PAD_FRAC = 0.20  # render 20% larger on each side, then crop
+
+
+def _hex_to_rgb(hex_color: str) -> tuple[int, int, int]:
+    h = hex_color.lstrip("#")
+    return tuple(int(h[i:i+2], 16) for i in (0, 2, 4))
+
+
+def _avg_color(palette: list[str]) -> tuple[int, int, int]:
+    rgbs = [_hex_to_rgb(c) for c in palette]
+    return tuple(sum(ch) // len(ch) for ch in zip(*rgbs))
+
+
+class GeometricStyle(GradientStyle):
+    def __init__(
+        self,
+        width: int,
+        height: int,
+        palette: list[str],
+        rows: int = 6,
+        cols: int = 6,
+        jitter: float = 0.3,
+        seed: int = None,
+    ):
+        super().__init__(width, height)
+        self.palette = palette
+        self.rows = rows
+        self.cols = cols
+        self.jitter = jitter
+        self.seed = seed
+
+    def render(self) -> Image.Image:
+        rng = random.Random(self.seed)
+
+        # Draw on a padded, 2× supersampled canvas then crop to final size
+        pad_w = int(self.width * PAD_FRAC)
+        pad_h = int(self.height * PAD_FRAC)
+        canvas_w = (self.width + 2 * pad_w) * SUPERSAMPLE
+        canvas_h = (self.height + 2 * pad_h) * SUPERSAMPLE
+
+        cell_w = canvas_w / self.cols
+        cell_h = canvas_h / self.rows
+
+        def jittered(x: float, y: float) -> tuple[float, float]:
+            return (
+                x + rng.uniform(-self.jitter, self.jitter) * cell_w,
+                y + rng.uniform(-self.jitter, self.jitter) * cell_h,
+            )
+
+        pts = [
+            [jittered(c * cell_w, r * cell_h) for c in range(self.cols + 1)]
+            for r in range(self.rows + 1)
+        ]
+
+        # Fill with blended average color so jitter gaps show a sensible color
+        img = Image.new("RGB", (canvas_w, canvas_h), _avg_color(self.palette))
+        draw = ImageDraw.Draw(img)
+
+        for r in range(self.rows):
+            for c in range(self.cols):
+                tl, tr = pts[r][c], pts[r][c + 1]
+                bl, br = pts[r + 1][c], pts[r + 1][c + 1]
+                draw.polygon([tl, tr, br], fill=_hex_to_rgb(rng.choice(self.palette)))
+                draw.polygon([tl, bl, br], fill=_hex_to_rgb(rng.choice(self.palette)))
+
+        # Crop to the non-padded region, then downsample
+        x0, y0 = pad_w * SUPERSAMPLE, pad_h * SUPERSAMPLE
+        img = img.crop((x0, y0, x0 + self.width * SUPERSAMPLE, y0 + self.height * SUPERSAMPLE))
+        return img.resize((self.width, self.height), Image.LANCZOS)
+
+
+def random_params(width: int, height: int, rng: random.Random) -> dict:
+    n = rng.randint(4, 7)
+    return {
+        "palette": color_utils.random_palette(rng, n, scheme="analogous"),
+        "rows": rng.randint(9, 18),
+        "cols": rng.randint(9, 18),
+        "jitter": rng.uniform(0.08, 0.22),
+        "seed": rng.randint(0, 2 ** 31),
+    }

styles/gradient_ramp.py

@@ -0,0 +1,58 @@
+import math
+import random
+import numpy as np
+from PIL import Image
+from core.base import GradientStyle
+from core import color_utils
+
+SUPERSAMPLE = 3
+
+
+def _hex_to_rgb(hex_color: str) -> tuple[int, int, int]:
+    h = hex_color.lstrip("#")
+    return tuple(int(h[i:i+2], 16) for i in (0, 2, 4))
+
+
+def _interpolate_stops(t: np.ndarray, colors: list[str]) -> np.ndarray:
+    n = len(colors)
+    rgbs = np.array([_hex_to_rgb(c) for c in colors], dtype=np.float32)
+    stops = np.linspace(0, 1, n)
+    out = np.zeros((*t.shape, 3), dtype=np.float32)
+    for i in range(n - 1):
+        mask = (t >= stops[i]) & (t <= stops[i + 1])
+        lt = (t[mask] - stops[i]) / (stops[i + 1] - stops[i])
+        out[mask] = rgbs[i] * (1 - lt[..., None]) + rgbs[i + 1] * lt[..., None]
+    return out.astype(np.uint8)
+
+
+class GradientRampStyle(GradientStyle):
+    def __init__(self, width: int, height: int, colors: list[str], steps: int = 6, angle: float = 0.0):
+        super().__init__(width, height)
+        self.colors = colors
+        self.steps = steps
+        self.angle = angle
+
+    def render(self) -> Image.Image:
+        W, H = self.width * SUPERSAMPLE, self.height * SUPERSAMPLE
+        rad = math.radians(self.angle)
+        cos_a, sin_a = math.cos(rad), math.sin(rad)
+        ys, xs = np.mgrid[0:H, 0:W]
+        cx, cy = W / 2, H / 2
+        proj = (xs - cx) * cos_a + (ys - cy) * sin_a
+        proj -= proj.min()
+        denom = proj.max()
+        t_cont = proj / denom if denom != 0 else proj
+
+        t_quantized = np.clip(np.floor(t_cont * self.steps) / self.steps, 0, 1)
+        img_arr = _interpolate_stops(t_quantized.astype(np.float32), self.colors)
+        big = Image.fromarray(img_arr, "RGB")
+        return big.resize((self.width, self.height), Image.LANCZOS)
+
+
+def random_params(width: int, height: int, rng: random.Random) -> dict:
+    n = rng.randint(2, 4)
+    return {
+        "colors": color_utils.random_palette(rng, n, scheme="analogous"),
+        "steps": rng.randint(4, 10),
+        "angle": rng.uniform(0, 360),
+    }

styles/linear.py

@@ -0,0 +1,53 @@
+import math
+import random
+import numpy as np
+from PIL import Image
+from core.base import GradientStyle
+from core import color_utils
+
+
+def _hex_to_rgb(hex_color: str) -> tuple[int, int, int]:
+    h = hex_color.lstrip("#")
+    return tuple(int(h[i:i+2], 16) for i in (0, 2, 4))
+
+
+def _to_linear(v: np.ndarray) -> np.ndarray:
+    """sRGB → linear light (gamma decode)."""
+    v = v / 255.0
+    return np.where(v <= 0.04045, v / 12.92, ((v + 0.055) / 1.055) ** 2.4)
+
+
+def _to_srgb(v: np.ndarray) -> np.ndarray:
+    """Linear light → sRGB (gamma encode)."""
+    return np.where(v <= 0.0031308, v * 12.92, 1.055 * v ** (1.0 / 2.4) - 0.055)
+
+
+class LinearGradient(GradientStyle):
+    def __init__(self, width: int, height: int, colors: list[str], angle: float = 0.0):
+        super().__init__(width, height)
+        self.colors = colors
+        self.angle = angle
+
+    def render(self) -> Image.Image:
+        rad = math.radians(self.angle)
+        cos_a, sin_a = math.cos(rad), math.sin(rad)
+
+        ys, xs = np.mgrid[0:self.height, 0:self.width]
+        cx, cy = self.width / 2, self.height / 2
+        proj = (xs - cx) * cos_a + (ys - cy) * sin_a
+        proj -= proj.min()
+        denom = proj.max()
+        t = (proj / denom if denom != 0 else proj).astype(np.float32)
+
+        c0 = _to_linear(np.array(_hex_to_rgb(self.colors[0]), dtype=np.float32))
+        c1 = _to_linear(np.array(_hex_to_rgb(self.colors[1]), dtype=np.float32))
+        blended_lin = c0 * (1 - t[..., None]) + c1 * t[..., None]
+        img_arr = np.clip(_to_srgb(blended_lin) * 255, 0, 255).astype(np.uint8)
+        return Image.fromarray(img_arr, "RGB")
+
+
+def random_params(width: int, height: int, rng: random.Random) -> dict:
+    return {
+        "colors": color_utils.random_palette(rng, 2, scheme="complementary"),
+        "angle": rng.uniform(0, 360),
+    }

styles/mesh.py

@@ -0,0 +1,53 @@
+import random
+import numpy as np
+from PIL import Image
+from core.base import GradientStyle
+from core import color_utils
+
+
+def _hex_to_rgb(hex_color: str) -> tuple[int, int, int]:
+    h = hex_color.lstrip("#")
+    return tuple(int(h[i:i+2], 16) for i in (0, 2, 4))
+
+
+def _idw_blend(xs: np.ndarray, ys: np.ndarray, points: np.ndarray, colors: np.ndarray, power: float = 3.0) -> np.ndarray:
+    coords = np.stack([xs.ravel(), ys.ravel()], axis=-1).astype(np.float32)
+    diffs = coords[:, None, :] - points[None, :, :]
+    dist2 = (diffs ** 2).sum(axis=-1)
+    dist2 = np.maximum(dist2, 1e-10)
+    weights = 1.0 / dist2 ** (power / 2)
+    weights /= weights.sum(axis=-1, keepdims=True)
+    blended = (weights[:, :, None] * colors[None, :, :]).sum(axis=1)
+    return blended.reshape(*xs.shape, 3).astype(np.uint8)
+
+
+class MeshGradient(GradientStyle):
+    def __init__(self, width: int, height: int, colors: list[str], grid: tuple[int, int] = (3, 3)):
+        super().__init__(width, height)
+        self.colors = colors
+        self.grid = grid
+
+    def render(self) -> Image.Image:
+        rows, cols = self.grid
+        n_points = rows * cols
+        gx = np.linspace(0, self.width - 1, cols)
+        gy = np.linspace(0, self.height - 1, rows)
+        gxx, gyy = np.meshgrid(gx, gy)
+        points = np.stack([gxx.ravel(), gyy.ravel()], axis=-1)
+
+        rgbs = [_hex_to_rgb(self.colors[i % len(self.colors)]) for i in range(n_points)]
+        colors_arr = np.array(rgbs, dtype=np.float32)
+
+        ys, xs = np.mgrid[0:self.height, 0:self.width]
+        img_arr = _idw_blend(xs, ys, points, colors_arr)
+        return Image.fromarray(img_arr, "RGB")
+
+
+def random_params(width: int, height: int, rng: random.Random) -> dict:
+    rows = rng.randint(2, 5)
+    cols = rng.randint(2, 5)
+    n = rows * cols
+    return {
+        "colors": color_utils.random_palette(rng, n, scheme="analogous"),
+        "grid": (rows, cols),
+    }

styles/multicolor.py

@@ -0,0 +1,68 @@
+import math
+import random
+import numpy as np
+from PIL import Image
+from core.base import GradientStyle
+from core import color_utils
+
+
+def _hex_to_rgb(hex_color: str) -> tuple[int, int, int]:
+    h = hex_color.lstrip("#")
+    return tuple(int(h[i:i+2], 16) for i in (0, 2, 4))
+
+
+def _to_linear(v: np.ndarray) -> np.ndarray:
+    v = v / 255.0
+    return np.where(v <= 0.04045, v / 12.92, ((v + 0.055) / 1.055) ** 2.4)
+
+
+def _to_srgb(v: np.ndarray) -> np.ndarray:
+    return np.where(v <= 0.0031308, v * 12.92, 1.055 * v ** (1.0 / 2.4) - 0.055)
+
+
+def _interpolate_stops_linear_light(t: np.ndarray, colors: list[str]) -> np.ndarray:
+    n = len(colors)
+    rgbs_lin = np.array([_to_linear(np.array(_hex_to_rgb(c), dtype=np.float32)) for c in colors])
+    stops = np.linspace(0, 1, n)
+    out = np.zeros((*t.shape, 3), dtype=np.float32)
+    for i in range(n - 1):
+        mask = (t >= stops[i]) & (t <= stops[i + 1])
+        lt = (t[mask] - stops[i]) / (stops[i + 1] - stops[i])
+        out[mask] = rgbs_lin[i] * (1 - lt[..., None]) + rgbs_lin[i + 1] * lt[..., None]
+    return np.clip(_to_srgb(out) * 255, 0, 255).astype(np.uint8)
+
+
+class MulticolorGradient(GradientStyle):
+    def __init__(self, width: int, height: int, colors: list[str], angle: float = 0.0, mode: str = "linear"):
+        super().__init__(width, height)
+        self.colors = colors
+        self.angle = angle
+        self.mode = mode
+
+    def render(self) -> Image.Image:
+        ys, xs = np.mgrid[0:self.height, 0:self.width]
+        if self.mode == "radial":
+            cx, cy = self.width / 2, self.height / 2
+            dist = np.sqrt((xs - cx) ** 2 + (ys - cy) ** 2)
+            r = max(self.width, self.height) * 0.72
+            t = np.clip(dist / r, 0, 1).astype(np.float32)
+        else:
+            rad = math.radians(self.angle)
+            cos_a, sin_a = math.cos(rad), math.sin(rad)
+            cx, cy = self.width / 2, self.height / 2
+            proj = (xs - cx) * cos_a + (ys - cy) * sin_a
+            proj -= proj.min()
+            denom = proj.max()
+            t = (proj / denom if denom != 0 else proj).astype(np.float32)
+
+        return Image.fromarray(_interpolate_stops_linear_light(t, self.colors), "RGB")
+
+
+def random_params(width: int, height: int, rng: random.Random) -> dict:
+    mode = rng.choice(["linear", "radial"])
+    n = 2 if mode == "radial" else rng.randint(3, 5)
+    return {
+        "colors": color_utils.random_palette(rng, n, scheme="analogous"),
+        "angle": rng.uniform(0, 360),
+        "mode": mode,
+    }

styles/radial.py

@@ -0,0 +1,55 @@
+import random
+import numpy as np
+from PIL import Image
+from core.base import GradientStyle
+from core import color_utils
+
+
+def _hex_to_rgb(hex_color: str) -> tuple[int, int, int]:
+    h = hex_color.lstrip("#")
+    return tuple(int(h[i:i+2], 16) for i in (0, 2, 4))
+
+
+def _to_linear(v: np.ndarray) -> np.ndarray:
+    v = v / 255.0
+    return np.where(v <= 0.04045, v / 12.92, ((v + 0.055) / 1.055) ** 2.4)
+
+
+def _to_srgb(v: np.ndarray) -> np.ndarray:
+    return np.where(v <= 0.0031308, v * 12.92, 1.055 * v ** (1.0 / 2.4) - 0.055)
+
+
+class RadialGradient(GradientStyle):
+    def __init__(
+        self,
+        width: int,
+        height: int,
+        colors: list[str],
+        center: tuple[float, float] = (0.5, 0.5),
+        radius: float = None,
+    ):
+        super().__init__(width, height)
+        self.colors = colors
+        self.center = center
+        self.radius = radius if radius is not None else max(width, height) * 0.7
+
+    def render(self) -> Image.Image:
+        cx = self.center[0] * self.width
+        cy = self.center[1] * self.height
+        ys, xs = np.mgrid[0:self.height, 0:self.width]
+        dist = np.sqrt((xs - cx) ** 2 + (ys - cy) ** 2)
+        t = np.clip(dist / self.radius, 0, 1).astype(np.float32)
+
+        c0 = _to_linear(np.array(_hex_to_rgb(self.colors[0]), dtype=np.float32))
+        c1 = _to_linear(np.array(_hex_to_rgb(self.colors[1]), dtype=np.float32))
+        blended_lin = c0 * (1 - t[..., None]) + c1 * t[..., None]
+        img_arr = np.clip(_to_srgb(blended_lin) * 255, 0, 255).astype(np.uint8)
+        return Image.fromarray(img_arr, "RGB")
+
+
+def random_params(width: int, height: int, rng: random.Random) -> dict:
+    return {
+        "colors": color_utils.random_palette(rng, 2, scheme="analogous"),
+        "center": (rng.uniform(0.25, 0.75), rng.uniform(0.25, 0.75)),
+        "radius": max(width, height) * rng.uniform(0.45, 0.85),
+    }

styles/shape_blur.py

@@ -0,0 +1,71 @@
+import random
+import colorsys
+import numpy as np
+from PIL import Image, ImageDraw, ImageFilter
+from core.base import GradientStyle
+from core import color_utils
+
+
+def _hex_to_rgb(hex_color: str) -> tuple[int, int, int]:
+    h = hex_color.lstrip("#")
+    return tuple(int(h[i:i+2], 16) for i in (0, 2, 4))
+
+
+class ShapeBlurGradient(GradientStyle):
+    def __init__(
+        self,
+        width: int,
+        height: int,
+        bg_color: str,
+        blob_colors: list[str],
+        num_blobs: int = 5,
+        blur_radius: int = 80,
+        seed: int = None,
+    ):
+        super().__init__(width, height)
+        self.bg_color = bg_color
+        self.blob_colors = blob_colors
+        self.num_blobs = num_blobs
+        self.blur_radius = blur_radius
+        self.seed = seed
+
+    def render(self) -> Image.Image:
+        rng = random.Random(self.seed)
+
+        base = Image.new("RGBA", (self.width, self.height), (*_hex_to_rgb(self.bg_color), 255))
+
+        blob_layer = Image.new("RGBA", (self.width, self.height), (0, 0, 0, 0))
+        draw = ImageDraw.Draw(blob_layer)
+
+        for i in range(self.num_blobs):
+            color = self.blob_colors[i % len(self.blob_colors)]
+            r, g, b = _hex_to_rgb(color)
+            alpha = rng.randint(160, 220)
+            cx = rng.randint(-self.width // 6, self.width + self.width // 6)
+            cy = rng.randint(-self.height // 6, self.height + self.height // 6)
+            rx = rng.randint(self.width // 5, self.width // 2)
+            ry = rng.randint(self.height // 5, self.height // 2)
+            draw.ellipse([cx - rx, cy - ry, cx + rx, cy + ry], fill=(r, g, b, alpha))
+
+        blob_layer = blob_layer.filter(ImageFilter.GaussianBlur(radius=self.blur_radius))
+        composite = Image.alpha_composite(base, blob_layer)
+        return composite.convert("RGB")
+
+
+def random_params(width: int, height: int, rng: random.Random) -> dict:
+    # Light, desaturated background — gives the "frosted glass" look
+    h = rng.random()
+    bg_r, bg_g, bg_b = colorsys.hsv_to_rgb(h, 0.08, 0.96)
+    bg_color = "#{:02x}{:02x}{:02x}".format(int(bg_r * 255), int(bg_g * 255), int(bg_b * 255))
+
+    # Blob colors: analogous family, vivid so they show through the blur
+    blob_colors = color_utils.random_palette(rng, rng.randint(3, 5), scheme="analogous")
+
+    blur = max(30, min(width, height) // 6)
+    return {
+        "bg_color": bg_color,
+        "blob_colors": blob_colors,
+        "num_blobs": rng.randint(4, 7),
+        "blur_radius": rng.randint(blur, blur * 2),
+        "seed": rng.randint(0, 2 ** 31),
+    }