I got an AI to make a gradio interface for this and it is delightful.

[naraphim]

import os
import time
import gradio as gr
import torch
from carvekit.api.high import HiInterface
from PIL import Image
import numpy as np

where to save outputs

OUTPUT_DIR = r"E:\backgroundRemover\Outputs"
os.makedirs(OUTPUT_DIR, exist_ok=True)

pick GPU if available

device = "cuda" if torch.cuda.is_available() else "cpu"

initialize CarveKit

interface = HiInterface(
object_type="hairs-like",
batch_size_seg=1,
batch_size_matting=1,
device=device,
seg_mask_size=320,
matting_mask_size=2048,
trimap_prob_threshold=231,
trimap_dilation=30,
trimap_erosion_iters=5,
fp16=False
)

def remove_background(img: np.ndarray) -> Image.Image:
pil_img = Image.fromarray(img)
result = interface([pil_img])[0]
timestamp = int(time.time())
out_path = os.path.join(OUTPUT_DIR, f"transparent_{timestamp}.png")
result.save(out_path)
return result

demo = gr.Interface(
fn=remove_background,
inputs=gr.Image(type="numpy"),
outputs=gr.Image(type="pil"),
title="AI Background Remover",
description="Upload a photo and download a PNG with a transparent background"
)

if name == "main":
demo.launch(server_name="127.0.0.1", server_port=7860)

obviously there is a hard coded path in there "E:\backgroundRemover\Outputs" but if someone wanted I'm sure they could change that.

[naraphim]

Then I got AI to add batch processing.

import os
import time
import torch
import gradio as gr
from PIL import Image
import numpy as np
from carvekit.api.high import HiInterface

--- SETUP ---

output folder

OUTPUT_DIR = r"E:\backgroundRemover\Outputs"
os.makedirs(OUTPUT_DIR, exist_ok=True)

pick GPU if available

device = "cuda" if torch.cuda.is_available() else "cpu"

initialize CarveKit

print("Initializing CarveKit interface...")
interface = HiInterface(
object_type="hairs-like",
batch_size_seg=1,
batch_size_matting=1,
device=device,
seg_mask_size=320,
matting_mask_size=2048,
trimap_prob_threshold=231,
trimap_dilation=30,
trimap_erosion_iters=5,
fp16=False
)
print("CarveKit interface loaded.")

--- HELPER FUNCTIONS ---

def clear_image():
return gr.update(value=None)

def pick_folder():
# This part requires a desktop environment to show the dialog
try:
import tkinter as tk
from tkinter import filedialog
root = tk.Tk()
root.withdraw()
return filedialog.askdirectory(title="Select folder with images")
except ImportError:
print("tkinter not found. Please paste the folder path manually.")
return "tkinter not available"

def clear_folder():
return ""

def batch_process(img: np.ndarray, folder_path: str):
"""
Processes a single image or a batch of images from a folder.
This function is NOT a generator and returns results at the end.
"""
exts = (".jpg", ".jpeg", ".png", ".webp")
last_result = None
progress_updates = []

# if a folder was chosen, process all matching files
if folder_path and os.path.isdir(folder_path):
    files = []
    for root_dir, _, names in os.walk(folder_path):
        for name in names:
            if name.lower().endswith(exts):
                files.append(os.path.join(root_dir, name))
    
    if not files:
        return None, "No images found in the selected folder."

    total = len(files)
    print(f"Found {total} images. Starting batch processing...")
    for idx, filepath in enumerate(files, start=1):
        progress_msg = f"Processing image {idx} of {total}: {os.path.basename(filepath)}"
        print(progress_msg) # Print to console for real-time feedback
        progress_updates.append(progress_msg)
        
        try:
            pil_in = Image.open(filepath).convert("RGB")
            result = interface([pil_in])[0]
            base = os.path.splitext(os.path.basename(filepath))[0]
            out_name = f"{base}_transparent.png"
            result.save(os.path.join(OUTPUT_DIR, out_name))
            last_result = result # Keep track of the last processed image
        except Exception as e:
            print(f"Error processing {filepath}: {e}")
            progress_updates.append(f"ERROR on {os.path.basename(filepath)}")


    final_message = f"Finished processing {total} images. Check the output folder.\n---\n" + "\n".join(progress_updates)
    return last_result, final_message

# fallback: single-image mode
elif img is not None:
    print("Processing single image...")
    pil_img = Image.fromarray(img)
    result = interface([pil_img])[0]
    ts = int(time.time())
    out_name = f"single_{ts}.png"
    result.save(os.path.join(OUTPUT_DIR, out_name))
    print("Single image processing done.")
    return result, "Done. Image saved to output folder."

else:
    return None, "Please upload a single image or select a folder, then click Submit."

--- GRADIO UI ---

CSS: left-align rows, auto-size buttons, hide flag icon

custom_css = """
.gradio-container .gr-row { justify-content: flex-start !important; }
.gradio-container .gr-button { width: auto !important; margin-right: 12px; }
button[title*="Flag"] { display: none !important; }
"""

with gr.Blocks(css=custom_css, title="AI Background Remover") as demo:
gr.Markdown("# AI Background Remover")
gr.Markdown("Upload a single image or pick a folder, then click Submit. For batch processing, progress will be shown in the console.")

with gr.Row():
    submit_btn     = gr.Button("Submit", variant="primary")
    clear_img_btn  = gr.Button("Clear Image", variant="secondary")

with gr.Row():
    folder_btn       = gr.Button("Browse Folder")
    clear_folder_btn = gr.Button("Clear Path", variant="secondary")
    folder_tb        = gr.Textbox(label="Folder Path", info="Path to folder containing images for batch processing.")

with gr.Row():
    img_input  = gr.Image(type="numpy", label="Input Image")
    img_output = gr.Image(type="pil",  label="Result")

progress_tb = gr.Textbox(label="Progress Log", interactive=False, lines=5)

# --- WIRE UP ACTIONS ---
clear_img_btn.click(clear_image, [], [img_input])
folder_btn.click(pick_folder,      [], [folder_tb])
clear_folder_btn.click(clear_folder, [], [folder_tb])

# The click event now calls the modified function without streaming
submit_btn.click(
    fn=batch_process,
    inputs=[img_input, folder_tb],
    outputs=[img_output, progress_tb]
)

if name == "main":
demo.launch(server_name="127.0.0.1", server_port=7860)

[naraphim]

0.6 seconds per image on a 4090.