OmniText-Bench

OmniText-Bench is a benchmark for controllable text-image manipulation (TIM). It evaluates five applications on the same 150 input images: text removal, rescaling, repositioning, editing (content and style-reference variants) and insertion (content and style-reference variants). Every sample ships with the input image, task masks, ground-truth results and, where applicable, a reference image for style transfer.

It was introduced in the ICLR 2026 paper OmniText: A Training-Free Generalist for Controllable Text-Image Manipulation.

• Project page: https://kaist-viclab.github.io/omnitext-site/
• Code: https://github.com/KAIST-VICLab/OmniText
• Paper: https://arxiv.org/abs/2510.24093

This is the public version of the dataset released on Feb 7, 2026.

Dataset at a glance

Item	Value
Input images	150 (512 x 512, RGBA PNG)
Applications	removal, rescaling, repositioning, editing (ref1 and ref2), insertion (ref1 and ref2)
Crop-warped text regions	256 x 64 RGB PNG
Total files	~6,300 PNGs, ~610 MB
Split	test only (evaluation benchmark)

ref1 uses a reference crop from the same image (content-driven editing/insertion). ref2 uses a reference crop from a different image (style-reference editing/insertion).

How to use

The dataset is stored as a plain folder tree plus labels.json. The simplest way to use it is to download the whole repository and read the JSON directly:

import json
from huggingface_hub import snapshot_download
from PIL import Image

root = snapshot_download(repo_id="agusgun/OmniText-Bench", repo_type="dataset")
labels = json.load(open(f"{root}/labels.json"))

sample = labels["001"]
img = Image.open(f"{root}/{sample['image']}")
removal = sample["application"]["removal"]
gt = Image.open(f"{root}/{removal['ground_truth']}")
print(removal["text"], removal["polygon"])

labels.jsonl is a flattened, one-row-per-sample copy of labels.json that powers the Hugging Face dataset viewer. Image columns in it are relative paths, not embedded images:

from datasets import load_dataset
ds = load_dataset("agusgun/OmniText-Bench", split="test")
print(ds[0]["removal_text"], ds[0]["removal_gt"])

Polygons are flat [x1, y1, x2, y2, ...] pixel-coordinate lists in the 512 x 512 input frame. Rasterised masks for each polygon are also provided as PNGs (see RemovalMask, TargetMask, RefMask).

Directory structure

./
├── Input/                                  # 150 input images (512x512)
├── labels.json                             # nested annotations (primary)
├── labels.jsonl                            # flat annotations (dataset viewer)
├── omnitext-bench-metadata.yaml            # per-image source credits
├── LICENSE.txt / TERMS.txt                 # license and third-party terms
└── Application/
    ├── Removal/
    │   ├── GT/                             # ground truth after removal
    │   ├── RemovalMask/                    # mask of the text to remove
    │   ├── GT_CropWarp/                    # crop-warped removal GT (256x64)
    │   ├── GT_CropWarp_Editing1/           # crop-warped removal GT, Editing ref1 frame
    │   ├── GT_CropWarp_Editing2/           # crop-warped removal GT, Editing ref2 frame
    │   ├── GT_CropWarp_Repositioning/      # crop-warped removal GT, Repositioning frame
    │   └── GT_CropWarp_Rescaling/          # crop-warped removal GT, Rescaling frame
    ├── Rescaling/
    │   ├── GT/  GT_CropWarp/
    │   ├── RemovalMask/                    # apply removal before rescaling
    │   └── TargetMask/                     # mask of the rescaled text region
    ├── Repositioning/
    │   ├── GT/  GT_CropWarp/
    │   ├── Removal_CropWarp/               # crop-warped removal result at target region
    │   ├── RemovalMask/
    │   └── TargetMask/                     # mask of the new text position
    ├── Editing/
    │   ├── RemovalMask/                    # mask of the text being edited
    │   ├── Ref1/                           # content-driven editing
    │   │   ├── GT/  GT_CropWarp/
    │   │   ├── RefImage/  RefImage_CropWarp/
    │   │   ├── RefMask/
    │   │   └── TargetMask/
    │   └── Ref2/                           # style-reference editing (same layout as Ref1)
    └── Insertion/
        ├── Ref1/                           # content-driven insertion (same layout as Editing/Ref1)
        └── Ref2/                           # style-reference insertion (same layout as Editing/Ref1)

Every subfolder holds 150 files named 001.png to 150.png, matching the keys in labels.json.

Label schema (labels.json)

{
    "001": {                                        // file id
        "image": str,                               // input image path relative to the root directory
        "application": {
            "removal": {
                "polygon": list[int],               // mask in polygon format
                "text": str,                        // source text
                "ground_truth": str                 // path to the ground truth
            },
            "rescaling": {
                "removal_polygon": list[int],       // removal mask in polygon format
                "target_polygon": list[int],        // target mask in polygon format
                "text": str,                        // target text
                "ground_truth": str
            },
            "repositioning": {
                "removal_polygon": list[int],
                "target_polygon": list[int],
                "text": str,
                "ground_truth": str
            },
            "editing": {
                "removal_polygon": list[int],
                "ref1": {                           // content-driven text editing
                    "text": {"source": str, "target": str},
                    "target_polygon": list[int],
                    "ground_truth": str,
                    "ref_polygon": list[int],       // reference mask in polygon format
                    "image": str                    // path to the reference image
                },
                "ref2": {...}                       // style-reference text editing
            },
            "insertion": {
                "ref1": {                           // content-driven text insertion
                    "text": str,                    // target text
                    "target_polygon": list[int],
                    "ground_truth": str,
                    "ref_polygon": list[int],
                    "image": str
                },
                "ref2": {...}                       // style-reference text insertion
            }
        }
    }
}

License and attribution

The annotations, masks and ground-truth renderings are released for non-commercial research use only (CC BY-NC style terms; see LICENSE.txt). The underlying mockup images come from third-party sources (MockupFree.co and creators aggregated by Freebiesbug.com) and remain under their original licenses. Per-image source links and credit text are listed in omnitext-bench-metadata.yaml, and the full third-party conditions are in TERMS.txt. By downloading this dataset you agree to those terms.

Citation

@inproceedings{gunawan2026omnitext,
    title={OmniText: A Training-Free Generalist for Controllable Text-Image Manipulation},
    author={Gunawan, Agus and Teodoro, Samuel and Chen, Yun and Kim, Soo Ye and Oh, Jihyong and Kim, Munchurl},
    booktitle={The Fourteenth International Conference on Learning Representations},
    year={2026},
    url={https://openreview.net/forum?id=zF7GyVXVw6}
}

Copyright: OmniText Team