SYNTOLOGY HomeExplorerAtlasCodeMethodologyAboutDevelopersFeedPricing
Paper · Lin_ShowUI_One_Vision-Language-Action_Model_for_GUI_Visual_Agent_CVPR_2025_paper · CVPR · 2025

ShowUI: One Vision-Language-Action Model for GUI Visual Agent

Kevin Lin, Linjie Li, Lijuan Wang, Difei Gao, Mike Shou, Zhengyuan Yang, Zechen Bai, Stan Lei, Shiwei Wu

Open in the Atlas

Code that ran

13 of 16 samples (functions and classes) lifted from this paper's linked repositories executed on a synthesized input in Syntology's jail (0 of them constructed an object rather than computing a result; 4 honoured the contract we drafted, 0 violated it and 0 have no contract verdict; 9 failures of our instrument; 3 no recorded run), measured 2026-11-21; bodies inline only under a permissive licence as GitHub detects it. Not a reproduction of the paper's results.

"Ran" means the function executed on a synthesized input and returned a value. It is not a reproduction of the paper's results. This record, dated, as JSON: /api/ran/Lin_ShowUI_One_Vision-Language-Action_Model_for_GUI_Visual_Agent_CVPR_2025_paper.json · badge: /api/ran/Lin_ShowUI_One_Vision-Language-Action_Model_for_GUI_Visual_Agent_CVPR_2025_paper.svg

Each repository's role is a label: a classifier's output recorded on the link, or, where no role is recorded, what the Papers with Code archive marked. The line under it names its basis. Neither says who wrote the code.

RepositoryRoleRan
showlab/ShowUI canonical (classifier label)
classifier basis: census
13 ran · 3 no recorded run
FunctionStatusWhere it lives
calculate_aitw_metrics Ran
ran; our contract draft was wrong, not the code
showlab/ShowUI/main/eval_aitw.py
code served (permissive licence) · get_code("fdf1a1edeca8987f")
How it ran

Ran in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API) and returned dict. The image it ran in was not recorded. If your copy returns the same type on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.

import logging

# Set up logging to see the info messages
logging.basicConfig(level=logging.INFO)

# Construct the results dictionary with the structure expected by calculate_aitw_metrics
results = {
    "episode_1": [
        {
            'corr_action': 1,
            'corr_type': 1,
            'num_text': 2,
            'corr_text': 1,
            'num_scroll': 1,
            'corr_scroll': 1,
            'num_click': 3,
            'corr_click': 2,
            'num_both_click': 1,
            'corr_both_click': 1,
            'num_wrong_format': 0,
        },
        {
            'corr_action': 0,
            'corr_type': 0,
            'num_text': 1,
            'corr_text': 0,
            'num_scroll': 2,
            'corr_scroll': 1,
            'num_click': 2,
            'corr_click': 1,
            'num_both_click': 0,
            'corr_both_click': 0,
            'num_wrong_format': 1,
        },
    ],
    "episode_2": [
        {
            'corr_action': 1,
            'corr_type': 1,
            'num_text': 3,
            'corr_text': 2,
            'num_scroll': 0,
            'corr_scroll': 0,
            'num_click': 1,
            'corr_click': 1,
            'num_both_click': 2,
            'corr_both_click': 1,
            'num_wrong_format': 0,
        },
    ],
}

ARGS = {
    'results': results,
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
none outside the standard library — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type dict — a dict output has no array shape of its own; none is stated — the instrument coerces any output to an array; for a dict output the recorded ndim 0 and dtype family float describe that coercion, not the output, and are not stated
Environment
image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
calculate_f1 Ran
ran, honoured the contract we drafted
showlab/ShowUI/main/eval_mind2web.py
code served (permissive licence) · get_code("c3c22ae25acb9f88")
How it ran

Ran in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API) and returned float, ndim 0, dtype family float, shape () as a later run recorded it. The image it ran in was not recorded. If your copy returns the same type, ndim and shape on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.

import torch
import numpy as np

torch.manual_seed(0)

# Analyze the function:
# - calculate_f1 takes two parameters: pred and label
# - Both parameters are used with .strip() and .split() methods
# - So they must be strings
# - The function computes F1 score on sets of words

ARGS = {
    "pred": "apple banana orange",
    "label": "apple banana cherry"
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
numpy, torch — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type float, ndim 0, dtype family float, shape () — shape () as a later run recorded it
dtype family
int means an integer dtype; float means any other dtype the instrument saw, bool and complex included (fixture_check.py records only these two families)
Environment
image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
find_target_linear_names Ran
ran; our contract draft was wrong, not the code
showlab/ShowUI/merge_weight.py
code served (permissive licence) · get_code("00c1146afbae58e2")
How it ran

Ran in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API) and returned list, ndim 1, dtype family float; no output shape is stated. The image it ran in was not recorded. If your copy returns the same type and ndim on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.

import torch
import torch.nn as nn

torch.manual_seed(0)

# Build a small model with nested Linear modules
class SimpleModel(nn.Module):
    def __init__(self):
        super().__init__()
        self.self_attn = nn.Linear(4, 3)  # This should be excluded
        self.lm_head = nn.Linear(4, 3)    # This should be excluded
        self.layer1 = nn.Linear(4, 3)     # This should be included
        self.layer2 = nn.Linear(4, 3)     # This should be included
        self.nested = nn.Sequential(
            nn.Linear(4, 3),              # This should be included
            nn.ReLU()
        )

model = SimpleModel()

ARGS = {
    'model': model,
    'num_lora_modules': -1,
    'lora_namespan_exclude': ['self_attn', 'lm_head'],
    'verbose': True
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
torch — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type list, ndim 1, dtype family float — a list output has no array shape of its own; none is stated
dtype family
int means an integer dtype; float means any other dtype the instrument saw, bool and complex included (fixture_check.py records only these two families)
Environment
image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
find_target_linear_names Ran
ran; our contract draft was wrong, not the code
showlab/ShowUI/model/utils.py
code served (permissive licence) · get_code("954a7534eb56091e")
How it ran

Ran in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API) and returned list, ndim 1, dtype family float; no output shape is stated. The image it ran in was not recorded. If your copy returns the same type and ndim on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.

import torch
import torch.nn as nn

torch.manual_seed(0)

class SimpleModel(nn.Module):
    def __init__(self):
        super().__init__()
        self.embedding = nn.Linear(4, 8)
        self.layer1 = nn.Linear(8, 16)
        self.self_attn = nn.Linear(16, 16)
        self.layer2 = nn.Linear(16, 8)
        self.lm_head = nn.Linear(8, 4)
        self.output = nn.Linear(8, 2)
    
    def forward(self, x):
        x = self.embedding(x)
        x = self.layer1(x)
        x = self.self_attn(x)
        x = self.layer2(x)
        x = self.output(x)
        return x

model = SimpleModel()

ARGS = {
    'model': model,
    'num_lora_modules': -1,
    'lora_namespan_exclude': ['self_attn', 'lm_head', 'vision_model', 'img_projection', 'visual_model'],
    'verbose': True
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
torch — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type list, ndim 1, dtype family float — a list output has no array shape of its own; none is stated
dtype family
int means an integer dtype; float means any other dtype the instrument saw, bool and complex included (fixture_check.py records only these two families)
Environment
image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
get_bbox Ran
ran, honoured the contract we drafted
showlab/ShowUI/main/eval_mind2web.py
code served (permissive licence) · get_code("722a5095911699c3")
How it ran

Ran in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API) and returned list, ndim 1, dtype family float; no output shape is stated. The image it ran in was not recorded. If your copy returns the same type and ndim on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.

import torch

torch.manual_seed(0)

meta = {
    'img_size': (640, 480),
    'step': {
        'bbox': {
            'x': 100,
            'y': 80,
            'width': 200,
            'height': 150
        }
    }
}

ARGS = {
    'meta': meta
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
torch — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type list, ndim 1, dtype family float — a list output has no array shape of its own; none is stated
dtype family
int means an integer dtype; float means any other dtype the instrument saw, bool and complex included (fixture_check.py records only these two families)
Environment
image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
get_bbox Ran
ran; the contract check could not run (RAISES, DEP_MISSING or TIMEOUT)
showlab/ShowUI/main/eval_screenspot.py
code served (permissive licence) · get_code("b6b2e338236414ad")
How it ran

Ran in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API) and returned list, ndim 1, dtype family float; no output shape is stated. The image it ran in was not recorded. If your copy returns the same type and ndim on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.

import torch

torch.manual_seed(0)

ARGS = {
    "bbox": [10, 20, 100, 150],
    "img_size": (640, 480),
    "xy_int": False
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
torch — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type list, ndim 1, dtype family float — a list output has no array shape of its own; none is stated
dtype family
int means an integer dtype; float means any other dtype the instrument saw, bool and complex included (fixture_check.py records only these two families)
Environment
image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
get_select_mask Ran
ran; our contract draft was wrong, not the code
showlab/ShowUI/model/showui/utils.py
code served (permissive licence) · get_code("be7b764c7115cbb6")
How it ran

Ran in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API) and returned Tensor, ndim 1, dtype family float, shape (10,) as a later run recorded it. The image it ran in was not recorded. If your copy returns the same type, ndim and shape on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.

import torch

torch.manual_seed(0)

# Construct a small tensor with some repeated values and -1 entries
# The tensor will have values that appear multiple times and single occurrences
tensor = torch.tensor([0, 0, 1, 1, 1, 2, -1, 3, 3, 0], dtype=torch.long)

ARGS = {
    "tensor": tensor,
    "skip_ratio": 0.3,
    "rand": False
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
torch — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type Tensor, ndim 1, dtype family float, shape (10,) — shape (10,) as a later run recorded it
dtype family
int means an integer dtype; float means any other dtype the instrument saw, bool and complex included (fixture_check.py records only these two families)
Environment
image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
load_sharded_weights Ran
ran; our contract draft was wrong, not the code
showlab/ShowUI/merge_weight.py
code served (permissive licence) · get_code("9dab4813f6ad1ea8")
How it ran

Ran in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API) and returned dict. The image it ran in was not recorded. If your copy returns the same type on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.

import os
import json
import torch
import tempfile
import shutil

torch.manual_seed(0)

# Create a temporary directory structure with sharded weights
temp_dir = tempfile.mkdtemp()
weight_dir = temp_dir

# Create sample weight shards
shard1_path = os.path.join(weight_dir, 'pytorch_model-00001-of-00002.bin')
shard2_path = os.path.join(weight_dir, 'pytorch_model-00002-of-00002.bin')

# Create sample tensors and save them
shard1_state = {
    'layer1.weight': torch.randn(4, 3),
    'layer1.bias': torch.randn(4),
}
shard2_state = {
    'layer2.weight': torch.randn(5, 4),
    'layer2.bias': torch.randn(5),
}

torch.save(shard1_state, shard1_path)
torch.save(shard2_state, shard2_path)

# Create the index file
index_data = {
    'weight_map': {
        'layer1.weight': 'pytorch_model-00001-of-00002.bin',
        'layer1.bias': 'pytorch_model-00001-of-00002.bin',
        'layer2.weight': 'pytorch_model-00002-of-00002.bin',
        'layer2.bias': 'pytorch_model-00002-of-00002.bin',
    }
}

index_file = os.path.join(weight_dir, 'pytorch_model.bin.index.json')
with open(index_file, 'w') as f:
    json.dump(index_data, f)

ARGS = {
    'weight_dir': weight_dir,
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
torch — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type dict — a dict output has no array shape of its own; none is stated — the instrument coerces any output to an array; for a dict output the recorded ndim 0 and dtype family float describe that coercion, not the output, and are not stated
Environment
image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
parse_args Ran
ran; our contract draft was wrong, not the code
showlab/ShowUI/merge_weight.py
code served (permissive licence) · get_code("331eaaacd445f7a8")
How it ran

Ran in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API) and returned Namespace. The image it ran in was not recorded. If your copy returns the same type on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.

import argparse

# Define ARGS dict with all parameters for parse_args
ARGS = {
    'args': [
        '--exp_dir',
        '/blob/v-lqinghong/experiments/ShowUI-RL/showui2-1e-4/2025-02-04_23-09-35/'
    ]
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
none outside the standard library — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type Namespace — a Namespace output has no array shape of its own; none is stated — the instrument coerces any output to an array; for a Namespace output the recorded ndim 0 and dtype family float describe that coercion, not the output, and are not stated
Environment
image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
parse_layer_type Ran
ran, honoured the contract we drafted
showlab/ShowUI/model/utils.py
code served (permissive licence) · get_code("46b7e6657cf825e7")
How it ran

Ran in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API) and returned list, ndim 1, dtype family int; no output shape is stated. The image it ran in was not recorded. If your copy returns the same type and ndim on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.

import torch
import re

torch.manual_seed(0)

# Analyzing the function:
# - str_ranges: a string containing bracket-enclosed ranges like "[1, 5, 2]"
# - L: an integer representing the length of the result list
# - default: an integer with default value 0

# The function parses a string to find patterns like [start, end, value]
# and constructs a list of length L with those values applied to ranges.

# Valid test cases:
str_ranges_1 = "[1, 3, 1] [4, 6, 2]"  # Two ranges
str_ranges_2 = "[2, 5, 3]"  # Single range
str_ranges_3 = ""  # Empty string - should return all defaults

L_1 = 10  # Length for result list
L_2 = 5
L_3 = 8

default_1 = 0  # Default value
default_2 = -1

ARGS = {
    "str_ranges": "[1, 3, 1] [4, 6, 2]",
    "L": 10,
    "default": 0
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
torch — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type list, ndim 1, dtype family int — a list output has no array shape of its own; none is stated
dtype family
int means an integer dtype; float means any other dtype the instrument saw, bool and complex included (fixture_check.py records only these two families)
Environment
image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
pointinbbox Ran
ran; the contract check could not run (RAISES, DEP_MISSING or TIMEOUT)
showlab/ShowUI/main/eval_screenspot.py
code served (permissive licence) · get_code("cfb0ea42d6d1e0ca")
How it ran

Ran in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API) and returned bool, ndim 0, dtype family float, shape () as a later run recorded it. The image it ran in was not recorded. If your copy returns the same type, ndim and shape on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.

import torch
import numpy as np

# The function checks if a point (pred_point) falls within a bounding box (gt_bbox)
# pred_point: expects a sequence with at least 2 elements [x, y]
# gt_bbox: expects a sequence with 4 elements [x_min, y_min, x_max, y_max]

# Create a valid point (x, y coordinates)
pred_point = [5.0, 5.0]

# Create a valid bounding box [x_min, y_min, x_max, y_max]
gt_bbox = [0.0, 0.0, 10.0, 10.0]

ARGS = {
    "pred_point": pred_point,
    "gt_bbox": gt_bbox
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
numpy, torch — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type bool, ndim 0, dtype family float, shape () — shape () as a later run recorded it
dtype family
int means an integer dtype; float means any other dtype the instrument saw, bool and complex included (fixture_check.py records only these two families)
Environment
image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
rotate_half Ran
ran; our contract draft was wrong, not the code
showlab/ShowUI/model/showui/modeling_showui.py
code served (permissive licence) · get_code("b99eea6376d1e212")
How it ran

Ran in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1) and returned Tensor, ndim 2, dtype family float, shape (2, 4) as a later run recorded it. The image it ran in was not recorded. If your copy returns the same type, ndim and shape on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.

import torch

torch.manual_seed(0)

# The function rotate_half takes a single parameter 'x' which is a tensor
# It accesses x.shape[-1] to get the last dimension
# It uses indexing with [..., :] slicing notation
# It calls torch.cat() to concatenate tensors

# Create a small tensor with shape (2, 4) - batch size 2, hidden dim 4
x = torch.randn(2, 4)

ARGS = {
    "x": x
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1
Imports
torch — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type Tensor, ndim 2, dtype family float, shape (2, 4) — shape (2, 4) as a later run recorded it
dtype family
int means an integer dtype; float means any other dtype the instrument saw, bool and complex included (fixture_check.py records only these two families)
Environment
image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
smart_resize Ran
ran, honoured the contract we drafted
showlab/ShowUI/model/showui/image_processing_showui.py
code served (permissive licence) · get_code("a50444314d796645")
How it ran

Ran in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API) and returned tuple, ndim 1, dtype family int; no output shape is stated. The image it ran in was not recorded. If your copy returns the same type and ndim on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.

import math

def smart_resize(height: int, width: int, factor: int=28, min_pixels: int=56 * 56, max_pixels: int=14 * 14 * 4 * 1280):
    """Rescales the image so that the following conditions are met:

    1. Both dimensions (height and width) are divisible by 'factor'.

    2. The total number of pixels is within the range ['min_pixels', 'max_pixels'].

    3. The aspect ratio of the image is maintained as closely as possible.

    """
    if height < factor or width < factor:
        raise ValueError(f'height:{height} or width:{width} must be larger than factor:{factor}')
    elif max(height, width) / min(height, width) > 200:
        raise ValueError(f'absolute aspect ratio must be smaller than 200, got {max(height, width) / min(height, width)}')
    h_bar = round(height / factor) * factor
    w_bar = round(width / factor) * factor
    if h_bar * w_bar > max_pixels:
        beta = math.sqrt(height * width / max_pixels)
        h_bar = math.floor(height / beta / factor) * factor
        w_bar = math.floor(width / beta / factor) * factor
    elif h_bar * w_bar < min_pixels:
        beta = math.sqrt(min_pixels / (height * width))
        h_bar = math.ceil(height * beta / factor) * factor
        w_bar = math.ceil(width * beta / factor) * factor
    return (h_bar, w_bar)


ARGS = {
    "height": 224,
    "width": 224,
    "factor": 28,
    "min_pixels": 56 * 56,
    "max_pixels": 14 * 14 * 4 * 1280,
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
none outside the standard library — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type tuple, ndim 1, dtype family int — a tuple output has no array shape of its own; none is stated
dtype family
int means an integer dtype; float means any other dtype the instrument saw, bool and complex included (fixture_check.py records only these two families)
Environment
image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
apply_multimodal_rotary_pos_emb Not yet run
unverified (harvested, no recorded run)
showlab/ShowUI/model/showui/modeling_showui.py
code served (permissive licence) · get_code("eb4d16c3bba7cff8")
How it ran

no invocation recorded.

apply_rotary_pos_emb_vision Not yet run
unverified (harvested, no recorded run)
showlab/ShowUI/model/showui/modeling_showui.py
code served (permissive licence) · get_code("48f12d3a9c4a15e8")
How it ran

no invocation recorded.

broadcast_value Not yet run
unverified (harvested, no recorded run)
showlab/ShowUI/main/eval_aitw.py
code served (permissive licence) · get_code("6bc574a30ca765af")
How it ran

no invocation recorded.

Also present in other papers' code

Of 16 samples lifted from this paper's linked repositories, 16 carry a function identity and 0 do not. Of the 16 distinct functions with an identity, 16 are also present in other papers whose code we hold (16 with at least one paper dated earlier, 0 the same month, 2 later) and 0 are only here among the 52,977 papers whose code Syntology holds (as of 2026-09-26).

Only here means: among the 52,977 papers whose code Syntology holds (51,887 with lifted samples, 1,090 through their assemblies only), as of 2026-09-26, no other paper's lifted samples or current assembly bricks contain an identical function body after normalisation.

FunctionAlso present inEarliest-datedOthers named
rotate_half 360 other papers
234 dated earlier, 42 later, 81 same year, order not determinable, 3 undated · 30 only as an assembly brick
1901.02860 (2019-01)
Transformer-XL: Attentive Language Models Beyond a Fixed-Length Context
2203.08913 (2022-03)
Memorizing Transformers
2302.13971 (2023-02)
LLaMA: Open and Efficient Foundation Language Models
and 357 more not named here
apply_multimodal_rotary_pos_emb 7 other papers
2 dated earlier, 1 later, 4 same year, order not determinable
2410.06169 (2024-10)
Treat Visual Tokens as Text? But Your MLLM Only Needs Fewer Efforts to See
2411.17465 (2024-11)
ShowUI: One Vision-Language-Action Model for GUI Visual Agent
2502.05173 (2025-02)
VideoRoPE: What Makes for Good Video Rotary Position Embedding?
and 4 more not named here
apply_rotary_pos_emb_vision 7 other papers
3 dated earlier, 4 same year, order not determinable
2407.17331 (2024-07)
Multi-label Cluster Discrimination for Visual Representation Learning
2410.06169 (2024-10)
Treat Visual Tokens as Text? But Your MLLM Only Needs Fewer Efforts to See
2411.17465 (2024-11)
ShowUI: One Vision-Language-Action Model for GUI Visual Agent
and 4 more not named here
smart_resize 5 other papers
1 dated earlier, 3 same year, order not determinable, 1 undated
2411.17465 (2024-11)
ShowUI: One Vision-Language-Action Model for GUI Visual Agent
2503.21620 (2025-03)
UI-R1: Enhancing Efficient Action Prediction of GUI Agents by Reinforcement Learning
2504.02949 (2025-04)
VARGPT-v1.1: Improve Visual Autoregressive Large Unified Model via Iterative Instruction Tuning and Reinforcement Learning
and 2 more not named here
broadcast_value 1 other paper
1 dated earlier
2411.17465 (2024-11)
ShowUI: One Vision-Language-Action Model for GUI Visual Agent
calculate_aitw_metrics 1 other paper
1 dated earlier
2411.17465 (2024-11)
ShowUI: One Vision-Language-Action Model for GUI Visual Agent
calculate_f1 1 other paper
1 dated earlier
2411.17465 (2024-11)
ShowUI: One Vision-Language-Action Model for GUI Visual Agent
find_target_linear_names 1 other paper
1 dated earlier
2411.17465 (2024-11)
ShowUI: One Vision-Language-Action Model for GUI Visual Agent
find_target_linear_names 1 other paper
1 dated earlier
2411.17465 (2024-11)
ShowUI: One Vision-Language-Action Model for GUI Visual Agent
get_bbox 1 other paper
1 dated earlier
2411.17465 (2024-11)
ShowUI: One Vision-Language-Action Model for GUI Visual Agent
get_bbox 1 other paper
1 dated earlier
2411.17465 (2024-11)
ShowUI: One Vision-Language-Action Model for GUI Visual Agent
get_select_mask 1 other paper
1 dated earlier
2411.17465 (2024-11)
ShowUI: One Vision-Language-Action Model for GUI Visual Agent
load_sharded_weights 1 other paper
1 dated earlier
2411.17465 (2024-11)
ShowUI: One Vision-Language-Action Model for GUI Visual Agent
parse_args 1 other paper
1 dated earlier
2411.17465 (2024-11)
ShowUI: One Vision-Language-Action Model for GUI Visual Agent
parse_layer_type 1 other paper
1 dated earlier
2411.17465 (2024-11)
ShowUI: One Vision-Language-Action Model for GUI Visual Agent
pointinbbox 1 other paper
1 dated earlier
2411.17465 (2024-11)
ShowUI: One Vision-Language-Action Model for GUI Visual Agent

Presence, not direction: an identical function body in two papers' repositories does not say who wrote it, which came from which, or that either paper's method rests on it. Matching is exact after normalisation, so a renamed or edited function is not matched. Dates are when papers appeared, not when code was written. Only .py files the harvester lifted are covered; notebooks are not read. A new-style arXiv id YYMM.NNNN dates a paper to the month 20YY-MM; otherwise Paper.year dates it to the year; otherwise it is undated. Dates are when the paper appeared, not when the code was written. Read 2026-11-21.

Repositories linked to this paper

Some links come from the archived Papers with Code dataset (CC BY-SA 4.0): attribution and licence.

Abstract

Building Graphical User Interface (GUI) assistants holds significant promise for enhancing human workflow productivity. While most agents are language-based, relying on closed-source API with text-rich meta-information (e.g., HTML or accessibility tree), they show limitations in perceiving UI visuals as humans do, highlighting the need for GUI visual agents. In this work, we develop a visionlanguage-action model in digital world, namely ShowUI, which features the following innovations: (i) UI-Guided Visual Token Selection to reduce computational costs by formulating screenshots as an UI connected graph, adaptively identifying their redundant relationship and serve as the criteria for token selection during self-attention blocks; (ii) Interleaved Vision-Language-Action Streaming that flexibly unifies diverse needs within GUI tasks, enabling effective management of visual-action history in navigation or pairing multi-turn query-action sequences per screenshot to enhance training efficiency; (iii) Small-scale Highquality GUI Instruction-following Datasets by careful data curation and employing a resampling strategy to address significant data type imbalances. With above components, ShowUI, a lightweight 2B model using 256K data, achieves a strong 75.1% accuracy in zero-shot screenshot grounding. Its UI-guided token selection further reduces 33% of redundant visual tokens during training and speeds up the performance by 1.4×. Navigation experiments across web [12], mobile [35], and online [39] environments further underscore the effectiveness and potential of our model in advancing GUI visual agents. The models are available at https://github.com/showlab/ShowUI.

For agents

The same record, over MCP at https://syntology.ai/mcp:

get_harvested_code_for_paper("Lin_ShowUI_One_Vision-Language-Action_Model_for_GUI_Visual_Agent_CVPR_2025_paper")
get_code_for_paper("Lin_ShowUI_One_Vision-Language-Action_Model_for_GUI_Visual_Agent_CVPR_2025_paper")
have("Lin_ShowUI_One_Vision-Language-Action_Model_for_GUI_Visual_Agent_CVPR_2025_paper")

The run record, dated, one paper per request, free:

curl https://syntology.ai/api/ran/Lin_ShowUI_One_Vision-Language-Action_Model_for_GUI_Visual_Agent_CVPR_2025_paper.json

A badge for a README (the split and the date, never a ratio):

[![Syntology run record](https://syntology.ai/api/ran/Lin_ShowUI_One_Vision-Language-Action_Model_for_GUI_Visual_Agent_CVPR_2025_paper.svg)](https://syntology.ai/paper/Lin_ShowUI_One_Vision-Language-Action_Model_for_GUI_Visual_Agent_CVPR_2025_paper)

Connect an agent — have() is free.