ICLight

Relight any image with AI-powered illumination control.

All examples can be run on GPU servers rented through CLORE.AI Marketplace.

All examples in this guide can be run on GPU servers rented through CLORE.AI Marketplace marketplace.

Renting on CLORE.AI

1. Visit CLORE.AI Marketplace

2. Filter by GPU type, VRAM, and price

3. Choose On-Demand (fixed rate) or Spot (bid price)

4. Configure your order:

   • Select Docker image

   • Set ports (TCP for SSH, HTTP for web UIs)

   • Add environment variables if needed

   • Enter startup command

5. Select payment: CLORE, BTC, or USDT/USDC

6. Create order and wait for deployment

Access Your Server

• Find connection details in My Orders

• Web interfaces: Use the HTTP port URL

• SSH: ssh -p <port> root@<proxy-address>

What is IC-Light?

IC-Light by lllyasviel enables:

• Relight images with text descriptions

• Change lighting direction and color

• Add or remove shadows

• Create studio lighting effects

• Foreground/background relighting

Resources

• GitHub: lllyasviel/IC-Light

• HuggingFace: lllyasviel/IC-Light

• Demo: HuggingFace Space

• Paper: Based on ControlNet architecture

Recommended Hardware

Component	Minimum	Recommended	Optimal
GPU	RTX 3060 12GB	RTX 4080 16GB	RTX 4090 24GB
VRAM	8GB	12GB	16GB
CPU	4 cores	8 cores	16 cores
RAM	16GB	32GB	64GB
Storage	30GB SSD	50GB NVMe	100GB NVMe
Internet	100 Mbps	500 Mbps	1 Gbps

Quick Deploy on CLORE.AI

Docker Image:

pytorch/pytorch:2.5.1-cuda12.4-cudnn9-devel

Ports:

22/tcp
7860/http

Command:

cd /workspace && \
git clone https://github.com/lllyasviel/IC-Light.git && \
cd IC-Light && \
pip install -r requirements.txt && \
python gradio_demo.py

Accessing Your Service

After deployment, find your http_pub URL in My Orders:

1. Go to My Orders page

2. Click on your order

3. Find the http_pub URL (e.g., abc123.clorecloud.net)

Use https://YOUR_HTTP_PUB_URL instead of localhost in examples below.

Installation

git clone https://github.com/lllyasviel/IC-Light.git
cd IC-Light
pip install -r requirements.txt

# Models download automatically on first run

What You Can Create

Product Photography

• Perfect lighting for e-commerce

• Consistent catalog images

• Studio-quality results without studio

Portrait Enhancement

• Fix bad lighting in photos

• Add dramatic lighting effects

• Create professional headshots

Creative Projects

• Mood transformation

• Day-to-night conversion

• Artistic lighting effects

Video Production

• Match lighting across scenes

• Create VFX-ready footage

• Fix on-location lighting issues

Marketing Materials

• Hero image creation

• Consistent brand imagery

• Quick photo retouching

Basic Usage

Foreground Relighting (FC Mode)

Relight subject with background intact:

import torch
from PIL import Image
from diffusers import StableDiffusionPipeline
from ic_light import ICLightFC

# Load model
model = ICLightFC.from_pretrained("lllyasviel/IC-Light-FC")
model.to("cuda")

# Load image
image = Image.open("portrait.jpg")

# Relight with text prompt
result = model.relight(
    image=image,
    prompt="golden hour sunlight from the left",
    num_inference_steps=25
)

result.save("relit_portrait.jpg")

Background Conditioned (FBC Mode)

Relight foreground to match new background:

from ic_light import ICLightFBC
from PIL import Image

model = ICLightFBC.from_pretrained("lllyasviel/IC-Light-FBC")
model.to("cuda")

# Load foreground and new background
foreground = Image.open("person.png")  # With transparent background
background = Image.open("sunset_scene.jpg")

# Relight to match background
result = model.relight(
    foreground=foreground,
    background=background,
    prompt="warm sunset lighting",
    num_inference_steps=25
)

result.save("composited.jpg")

Lighting Prompts

Direction-Based Lighting

prompts = [
    "bright light from the left side",
    "soft light from above",
    "dramatic backlight from behind",
    "rim lighting from the right",
    "front facing diffused light",
    "low angle light from below"
]

Color-Based Lighting

prompts = [
    "warm golden sunlight",
    "cool blue twilight",
    "neon pink light",
    "green ambient light",
    "orange sunset glow",
    "white studio lighting"
]

Environment-Based Lighting

prompts = [
    "outdoor daylight, bright sun",
    "indoor window light, soft shadows",
    "night city lights, neon reflections",
    "candlelight, warm flickering",
    "cloudy day, diffused lighting",
    "studio softbox, professional"
]

Batch Processing

import os
from PIL import Image
from ic_light import ICLightFC

model = ICLightFC.from_pretrained("lllyasviel/IC-Light-FC")
model.to("cuda")

input_dir = "./images"
output_dir = "./relit"
os.makedirs(output_dir, exist_ok=True)

lighting_prompt = "professional studio lighting, soft shadows"

for filename in os.listdir(input_dir):
    if not filename.endswith(('.jpg', '.png')):
        continue

    image = Image.open(os.path.join(input_dir, filename))

    result = model.relight(
        image=image,
        prompt=lighting_prompt,
        num_inference_steps=25
    )

    result.save(os.path.join(output_dir, f"relit_{filename}"))
    print(f"Processed: {filename}")

Multiple Lighting Variations

from ic_light import ICLightFC
from PIL import Image
import os

model = ICLightFC.from_pretrained("lllyasviel/IC-Light-FC")
model.to("cuda")

image = Image.open("product.jpg")

lighting_variations = {
    "daylight": "bright natural daylight, clean white background",
    "dramatic": "dramatic side lighting, dark shadows",
    "warm": "warm golden hour, soft orange glow",
    "cool": "cool blue lighting, modern aesthetic",
    "studio": "professional studio softbox, even lighting"
}

os.makedirs("./variations", exist_ok=True)

for name, prompt in lighting_variations.items():
    result = model.relight(
        image=image,
        prompt=prompt,
        num_inference_steps=25
    )
    result.save(f"./variations/{name}.jpg")
    print(f"Generated: {name}")

Gradio Interface

import gradio as gr
from PIL import Image
from ic_light import ICLightFC

model = ICLightFC.from_pretrained("lllyasviel/IC-Light-FC")
model.to("cuda")

def relight_image(image, prompt, steps, seed):
    generator = torch.Generator("cuda").manual_seed(seed) if seed > 0 else None

    result = model.relight(
        image=image,
        prompt=prompt,
        num_inference_steps=steps,
        generator=generator
    )

    return result

demo = gr.Interface(
    fn=relight_image,
    inputs=[
        gr.Image(type="pil", label="Input Image"),
        gr.Textbox(
            label="Lighting Prompt",
            value="professional studio lighting",
            placeholder="Describe the desired lighting..."
        ),
        gr.Slider(10, 50, value=25, step=5, label="Steps"),
        gr.Number(value=-1, label="Seed (-1 for random)")
    ],
    outputs=gr.Image(label="Relit Image"),
    title="IC-Light - AI Image Relighting",
    description="Change lighting in any image with text descriptions. Running on CLORE.AI GPU servers.",
    examples=[
        ["example.jpg", "golden hour sunlight from the left", 25, -1],
        ["example.jpg", "dramatic rim lighting, dark background", 25, -1],
        ["example.jpg", "soft window light, gentle shadows", 25, -1]
    ]
)

demo.launch(server_name="0.0.0.0", server_port=7860)

ComfyUI Integration

IC-Light is available as ComfyUI nodes:

cd ComfyUI/custom_nodes
git clone https://github.com/kijai/ComfyUI-IC-Light.git

ComfyUI Workflow

1. Load your image

2. Add IC-Light Loader node

3. Connect to IC-Light Apply node

4. Set lighting prompt

5. Connect to KSampler

6. Output to Save Image

With Background Removal

from ic_light import ICLightFBC
from rembg import remove
from PIL import Image

# Remove background first
original = Image.open("photo.jpg")
foreground = remove(original)

# Load new background
background = Image.open("studio_bg.jpg")

# Relight to match
model = ICLightFBC.from_pretrained("lllyasviel/IC-Light-FBC")
model.to("cuda")

result = model.relight(
    foreground=foreground,
    background=background,
    prompt="studio lighting matching background",
    num_inference_steps=25
)

result.save("composited.jpg")

Performance

Mode	Resolution	GPU	Speed
FC (foreground)	512x512	RTX 3090	3s
FC (foreground)	512x512	RTX 4090	2s
FBC (composite)	512x512	RTX 4090	3s
FC (foreground)	1024x1024	A100	4s

Model Variants

Model	Description	Use Case
IC-Light-FC	Foreground Consistent	Single image relighting
IC-Light-FBC	Foreground-Background Consistent	Compositing with backgrounds

Common Problems & Solutions

Lighting Doesn't Change

Problem: Output looks similar to input

Solutions:

• Use more descriptive lighting prompts

• Increase inference steps to 30-40

• Try different seed values

• Use stronger contrast in prompt (e.g., "dramatic" vs "soft")

# More descriptive prompt
result = model.relight(
    image=image,
    prompt="extremely bright dramatic spotlight from upper left, dark shadows on right side",
    num_inference_steps=35
)

Artifacts on Face/Details

Problem: Face or details look distorted

Solutions:

• Lower strength/guidance scale

• Use more inference steps

• Keep lighting changes subtle

• Post-process with face restoration

Color Shift Issues

Problem: Unwanted color changes

Solutions:

• Be specific about color in prompt

• Add "preserve original colors" to prompt

• Use color-neutral lighting descriptions

• Post-process color correction

Background Changes

Problem: Background changes when only foreground should

Solutions:

• Use FC mode (foreground consistent)

• Pre-process with background removal

• Use mask to isolate subject

Inconsistent Results

Problem: Same prompt gives very different results

Solutions:

• Set fixed seed for reproducibility

• Increase inference steps for stability

• Use simpler, more direct prompts

# Consistent results with fixed seed
result = model.relight(
    image=image,
    prompt=prompt,
    num_inference_steps=30,
    generator=torch.Generator("cuda").manual_seed(42)
)

Troubleshooting

Relighting looks unnatural

• Match lighting direction with scene

• Use appropriate light intensity

• Consider shadows in original image

Background affected

• Use foreground mask properly

• Segment subject from background first

• Adjust light falloff settings

Output too dark/bright

• Adjust light intensity values

• Use HDR output if available

• Post-process with curves

Model not loading

• Download all required checkpoints

• Check file integrity

• Verify CUDA compatibility

Cost Estimate

Typical CLORE.AI marketplace rates (as of 2024):

GPU	Hourly Rate	Daily Rate	4-Hour Session
RTX 3060	~$0.03	~$0.70	~$0.12
RTX 3090	~$0.06	~$1.50	~$0.25
RTX 4090	~$0.10	~$2.30	~$0.40
A100 40GB	~$0.17	~$4.00	~$0.70
A100 80GB	~$0.25	~$6.00	~$1.00

Prices vary by provider and demand. Check CLORE.AI Marketplace for current rates.

Save money:

• Use Spot market for flexible workloads (often 30-50% cheaper)

• Pay with CLORE tokens

• Compare prices across different providers

Next Steps

• TripoSR - Convert relit images to 3D

• Stable Diffusion - Generate images to relight

• ComfyUI - Advanced workflow integration

• Fooocus - Simple image generation