RULER trains an SVG-generating LLM with reinforcement learning by turning each text prompt into a custom six-item rubric, then using a vision-language judge’s item-by-item scores as a dense reward, avoiding the reward hacking that plagues CLIPScore or aesthetic-classifier rewards.
Suppose you’re building a system that emits Scalable Vector Graphics code from a natural-language prompt like “a honeycomb with a bee.” There’s no single correct picture. Ten different SVGs could all be great, so there is no pixel-level ground truth to train against.
That leaves two bad options today. Supervised fine-tuning on prompt/SVG pairs just teaches the model to copy the style of whatever dataset you had. RL is the natural fix, but RL needs a reward, and the available rewards were built for photos, not stylized vector art. CLIPScore and aesthetic classifiers were calibrated on natural images. The paper shows they routinely rank a broken SVG above a faithful one. Worse, when you plug them into RL as a reward, the policy learns to game them: the paper reports that optimizing a CLIP+Aesthetic+Human Preference Score combo drives the aesthetic score sky-high while the actual visual quality collapses (Rubric score falls from 0.395 to 0.262 on the icon benchmark, below the untrained baseline).
So the real bottleneck is not the RL algorithm. It’s the reward signal.
The core idea: instead of asking a judge model “how good is this SVG, 0 to 1,” ask it to grade the SVG on a checklist that was written specifically for this prompt.
For every training prompt, a frontier model (Claude-Opus-4.6 in the main runs) reads the instruction and writes a six-item rubric covering three axes: semantic fidelity (are the right objects visible?), visual quality (silhouette, composition), and rendering style (finish, cohesion). Each item has a title, a description, a continuous 0–1 scoring guide, and a fixed importance weight. Crucially, items are written at the level of “design intentions,” not “the bee must be at pixel (200, 150),” so many valid renderings can still score well.
At RL time, the policy samples 8 candidate SVG programs per prompt. Each is rendered to an image with CairoSVG. A judge VLM (Qwen3-VL-8B) scores each rendered image against that prompt’s rubric, item by item. Those six scores get combined into a weighted average, and that scalar is the reward. Because rewards vary across the 8 rollouts for the same prompt, the paper uses Group Relative Policy Optimization (GRPO) to compute advantages by normalizing within each group of 8, then does a standard clipped policy-gradient update.
One subtlety worth internalizing: the rubric never sees a ground-truth SVG. It’s generated from text alone. This is what makes the approach scale to any unannotated prompt set.
for prompt in training_prompts:
rubric = frontier_model.write_rubric(prompt) # 6 items, offline, cached
rollouts = policy.sample(prompt, n=8)
rewards = []
for svg_code in rollouts:
image = cairosvg.render(svg_code)
scores = judge_vlm.rate_each_item(image, prompt, rubric) # 6 floats in [0,1]
rewards.append(weighted_avg(scores, rubric.weights))
advantages = (rewards - mean(rewards)) / (std(rewards) + eps)
policy.grpo_update(rollouts, advantages)
The evaluation splits into two questions: is a rubric a good evaluator, and does it work as a reward?
As an evaluator. On 900 human-annotated SVGs, rubric scores from a VLM judge hit Spearman ρ = 0.7929 against human ratings, versus 0.6051 for the aesthetic classifier and 0.5518 for CLIP. Pairwise ranking agreement (Goodman–Kruskal γ) is similarly stronger. This is the empirical basis for using rubric scoring at all.
As a reward. On the MMSVG benchmark suite Illustration and Icon benchmarks, RULER lifts the Rubric score from 0.432 → 0.693 and 0.395 → 0.683 over its Qwen3-8B backbone, and matches the much larger DeepSeek-V3 while beating dedicated SVG specialists like OmniSVG and IconShop. Blinded human preference on 150 prompts gives RULER a non-tie win rate above 50% against every baseline (89.7% vs. its own Qwen3-8B backbone, 66.1% vs. Qwen3-32B).
The most informative ablation is the reward-design comparison, because it holds the base model and optimizer fixed and varies only what’s being rewarded:
•
CLIP + Aesthetic + HPS reward: aesthetic score explodes to 6.7 (from 4.3), but on Icon the Rubric score falls to 0.262, below zero-shot. The policy spams dense overlapping strokes, ballooning output length to 6.3k tokens vs. 0.3k. Classic reward hacking.
•
Universal (query-agnostic) rubric: healthy gains (Rubric 0.660 / 0.591), but still trails RULER’s instance-aware version by 0.033 / 0.092 points.
•
RULER (instance-aware): best on all four metrics.
Robustness checks: swapping the rubric generator from Claude-Opus-4.6 to GPT-5.5 gives similar results (0.646 vs. 0.662 on Icon). Swapping the policy from 8B to 4B still yields big gains. One negative result matters: an alternative rubric prompt called Rubric-S that removes the stylistic axis and adds a text-hint penalty caused the policy to start rendering the literal prompt words as stylized labels inside the SVG, dropping Rubric to 0.536. Rubric composition matters as much as scoring strictness.
•
If your task has no ground truth and you’re tempted to use CLIP as an RL reward, don’t. The C+A+H result is a clean cautionary tale: single-scalar visual rewards on domain-shifted content invite the policy to inflate the metric while degrading the artifact. A rubric with multiple independently-judgeable items is much harder to game because there is no single dimension to collapse onto.
•
The recipe is portable in principle to any open-ended generation task where you can (a) render or execute the output, (b) get a VLM or LLM to judge along multiple axes, and © write a per-instance checklist from the prompt alone. Diagram generation, UI mockups, and constrained code generation are natural candidates worth testing. The paper only evaluates SVG, so treat cross-domain transfer as a hypothesis.
•
Budget for judge-and-render cost. Every RL step renders 8 SVGs and calls a VLM judge on each. Offline rubric generation cost the authors about $0.07 per prompt with Claude-Opus-4.6 (roughly $2k for 30k prompts). Judge cost during training is on top of that. This is much more than a CLIP-based reward, and the paper flags it as a scalability constraint.
•
The rubric prompt is a hyperparameter you should validate. The Rubric-S ablation shows a well-intentioned rewrite can reopen a hacking channel. If you build this, run a small qualitative check on rollouts to catch shortcuts like text-in-image before spending a full training run.
•
The project page is linked; the authors say they will release rubrics, training data, and code.
•
The reward depends on two external models (a rubric writer and a VLM judge), so their biases become the policy’s biases. The judge can overvalue superficial cues.
•
Evaluation stays within the MMSVG distribution. Training and test prompts are separate, but the paper explicitly does not claim out-of-distribution generalization.
•
The primary “Rubric score” used to rank methods in Table 2 is itself a VLM-as-judge metric (GPT-5-mini with a universal rubric). It’s not the same rubric used for training, but the family of evaluator is similar to the family of reward, which is worth keeping in mind when reading the headline numbers. The human preference study is the stronger corroboration.
•
The fixed six-item, three-axis decomposition works for the benchmarks tested. Other domains, or artistic intents that don’t fit “semantic / visual / stylistic,” may need different axes.