ChartAnno: Evaluating MLLMs for Chart Annotation Generation

     

The official dataset repository of ChartAnno

1,200 real-world charts  ·  3,600 instructions  ·  7,200 model input instances  ·  17 chart types

1. Data Overview

Chart annotation is a communicative task that requires inferring intended messages, interpreting chart semantics, and placing appropriate textual or graphical elements. ChartAnno is a benchmark for evaluating multimodal large language models (MLLMs) on chart annotation generation: given an existing chart (as executable code, optionally with the rendered image) and an annotation instruction, the model generates executable code that adds the requested annotations.

ChartAnno includes 1,200 real-world charts, each with a paired annotated / unannotated ground-truth (code + rendered image) pair. Every chart is paired with annotation instructions across three levels of specificity — Intent, Operation, and Implementation — yielding 3,600 instruction instances, tested under two input settings (Input: code and Input: code+Image) for 7,200 model input instances in total.

_{Task design: two input settings (Code, Code + Image) × three instruction levels (Intent, Operation, Implementation).}

2. Task Formats

The dataset is organized into configs, one per input setting:

Config	Input setting	Model input	Ground truth
code_image	Input: code+Image	Instruction + unannotated chart code + chart image	Annotated code + annotated chart
code_only	Input: code	Instruction + unannotated chart code	Annotated code + annotated chart
d3_code_only	Input: code (D3.js)	Instruction + unannotated D3.js code	Annotated D3.js code + annotated chart
svg_code_only	Input: code (SVG)	Instruction + unannotated SVG document	Annotated SVG document + annotated chart

Each instance carries one of three instruction levels:

Level	Description
intent	Abstract communicative goal, e.g. "emphasize the strongest market". The model must infer what to annotate.
operation	Concrete annotation operations, e.g. "add an arrow pointing to the peak and a text label with its value".
implementation	Fully specified implementation details, e.g. exact label text, colors, and positions.

An example pair from the code_image config (Area_1): the model receives the unannotated chart on the left (with its code) and produces the annotated version on the right.

Input: GT w/o anno chart	Expected output: GT chart

D3.js / SVG extension (code-only)

Besides the main Matplotlib benchmark, the dataset ships a D3.js and SVG extension: 120 real-world charts (14 chart types), each paired with instructions across the same three levels — 360 rows per backend (d3_code_only, svg_code_only). Rows follow the same schema as code_only; ids carry a _d3 / _svg suffix, and the code files (.js / .svg) plus full-resolution images are included in chartanno_d3_svg.tar.gz.

3. Data Statistics

The statistics below are computed on the main Matplotlib (Python) benchmark; the D3/SVG extension follows the same construction.

Overall scale

Statistic	Value
GT pair and GT w/o anno pair	1,200
Instruction instances	3,600
Annotation elements	25,772

Annotation complexity

Statistic	Value
Avg. elements per chart	21.48
Std. elements per chart	35.32
Avg. annotation types per chart	2.17
Std. annotation types per chart	1.04

Instruction length (words)

Level	Avg.	Std.
Intent	66.39	52.97
Operation	95.06	63.57
Implementation	108.74	79.78

Code length (tokens)

Code	Avg.	Std.
Annotated	1535.68	972.38
Unannotated	1075.22	790.45
Increment	460.46	385.17

Chart type distribution (17 types)

Type	Multi	Line	Bar	Scatter	Errorpoint	Heatmap	Pie	Area	Histogram
Count	303	247	213	94	47	44	44	33	32

Type	Combination	Violin	Radar	Density	Treemap	Box	Contour	Dot	Total
Count	31	20	19	19	17	16	15	6	1,200

4. Download Link

This dataset is gated: click Request access on the repo page first. Once granted, you can download the whole dataset with a read token (settings/tokens):

pip install -U huggingface_hub
hf login --token $HF_TOKEN        # or: hf auth login

mkdir ChartAnno && cd ChartAnno   # cd to the target directory
hf download chartanno/ChartAnno chartanno.tar.gz --repo-type dataset --local-dir .
tar -xzvf chartanno.tar.gz

The optional D3/SVG extension ships as a separate archive:

hf download chartanno/ChartAnno chartanno_d3_svg.tar.gz --repo-type dataset --local-dir .
tar -xzvf chartanno_d3_svg.tar.gz   # extracts to ./d3_svg_data

The file structure of the dataset is as follows:

data/
├── input_code.jsonl              # Input: code task, 3,600 rows
├── input_code_image.jsonl        # Input: code+Image task, 3,600 rows
├── manifest.json                 # row-count summary and schema description
├── README.md
└── images/
    ├── GT_chart/                 # 1,200 annotated ground-truth charts (jpg)
    │   ├── Area/  Bar/  ...      # one subdirectory per chart type (17 types)
    └── GT_w_o_anno_chart/        # 1,200 unannotated charts, same layout

The Dataset Viewer above serves the full dataset: all 3,600 rows per config are loadable via load_dataset("chartanno/ChartAnno", "<config>"). Chart images in the viewer parquet are embedded as compressed JPEG thumbnails for fast previewing; the full-resolution images are included in chartanno.tar.gz.

5. Data Fields

We take an instance from the code_image config as an example (Area_1_intent_code_image, long values truncated):

{
  "id": "Area_1_intent_code_image",
  "category": "Area",
  "sample_id": "Area_1",
  "level": "intent",
  "input_type": "Input: code+Image",
  "instruction": "You are an expert in chart annotation and Python visualization. I have created a figure but have not added any annotations yet. ...",
  "GT w/o anno code": "import matplotlib.pyplot as plt\nimport numpy as np\nmonths = ['Jan', 'Feb', 'Mar', 'Apr', 'May', 'Jun', 'Jul', 'Aug', 'Sep', 'Oct', 'Nov', 'Dec']\nvisitors = [12, 120, 229, 990, 4104, 3250, 5720, 43152, ...",
  "GT w/o anno chart": "data/images/GT_w_o_anno_chart/Area/Area_1.jpg",
  "GT code": "import matplotlib.pyplot as plt\nimport numpy as np\nmonths = ['Jan', 'Feb', 'Mar', 'Apr', 'May', 'Jun', 'Jul', 'Aug', 'Sep', 'Oct', 'Nov', 'Dec']\nvisitors = [12, 120, 229, 990, 4104, 3250, 5720, 43152, ...",
  "GT chart": "data/images/GT_chart/Area/Area_1.jpg"
}

Details of the data fields are as follows:

Field	Description
id	Stable row id: <sample_id>_<level>_code or <sample_id>_<level>_code_image.
category	Chart type, one of 17 types (e.g. Area, Bar, Line).
sample_id	Source chart id, <Category>_<n> (e.g. Area_1).
level	Instruction level: intent, operation, or implementation.
input_type	Input: code or Input: code+Image.
instruction	The full model input prompt: task instruction with the unannotated code embedded.
GT w/o anno code	Ground-truth chart code before annotation.
GT w/o anno chart	Path to the unannotated chart image; always null in the code_only config.
GT code	Ground-truth annotated chart code.
GT chart	Path to the annotated ground-truth chart image.

Image paths are relative to the repository root of the extracted data/ folder. In the viewer parquet the two image fields are named gt_chart / gt_wo_anno_chart (space-free, for Dataset Viewer compatibility) and are embedded as compressed thumbnails of these files.

6. Evaluation

ChartAnno comes with a self-contained evaluation pipeline (see the GitHub repository): it renders the generated code into charts and scores them with rule-based metrics (execution success, chart fidelity, annotation matching, color matching) and LLM-judged metrics (semantic faithfulness, semantic clarity, visual clarity, annotation organization quality, attention guidance). The final aggregate scores are:

Aggregate	Inputs
Structural compliance	chart fidelity (+ annotation & color matching for operation/implementation levels)
Semantic consistency	semantic faithfulness, semantic clarity
Design effectiveness	visual clarity, annotation organization quality, attention guidance

7. Citation

If you find ChartAnno useful, please consider citing our paper:

@article{chen2026chartanno,
      title={ChartAnno: Evaluating MLLMs for Chart Annotation Generation},
      author={Zhenghan Chen and Zekai Shao and Lidan Tan and Xin Lin and Xingchen Zeng and Yi Shan and Ziyue Lin and Xiaoliang Fu and Xinyuan Liu and Yuetong Guo and Fen Wang and Bongshin Lee and Siming Chen},
      year={2026},
      journal={arXiv preprint arXiv:2608.03464},
}