Blog.md

🎨 DesignGym 2.0 — Teaching an LLM to Think Like a Designer

What if a machine didn't just generate a layout — but learned how to improve one?

---

The Big Idea

Imagine a blank canvas. On it, you can place anything — a headline, a hero image, a call-to-action, a sofa, a warehouse shelf, a hospital bed, a circuit component. The problem of arrangement is universal.

DesignGym 2.0 asks a radical question:

Can we train an LLM to reason about space — iteratively, purposefully, the way a designer does?

Not a one-shot generator. Not a template-picker. An agent that looks at a layout, diagnoses what's wrong, chooses a meaningful edit, and gets better over time through feedback.

That's what this project is. And it's bigger than posters.

Figure 1 — End-to-end architecture: the OpenEnv-compliant DesignGym environment, the heuristic planner that bootstraps SFT data, the SFT adapter that locks in the action interface, and the GRPO trainer that learns design preference from verifiable reward.

---

🌐 The Vision: A Canvas Is a Universal Problem

Here's what hit me building this: graphic design is just one instance of a much deeper problem.

Every time humans arrange objects under constraints to serve a goal, they are solving a layout problem:

• 🛋️ Interior Design — furniture in a room, flow, light, balance
• 🏭 Warehouse Planning — shelf placement, picking efficiency, safety zones
• 🏥 Hospital Floor Plans — patient flow, emergency access, quiet zones
• 💻 UI Dashboards — information hierarchy, click efficiency, accessibility
• 🖥️ Chip Placement (VLSI) — routing, thermal zones (a billion-dollar optimization problem)
• 🏫 Classroom Seating — learning groups, teacher sightlines, collaborative zones
• 🏪 Retail Layouts — foot traffic, product discovery, impulse zones
• 📰 Editorial Design — reading order, visual weight, column balance
• 🏙️ Urban Zoning — density, transit access, green space allocation

The abstract structure is always the same:

$$\text{objects}+\text{constraints}+\text{goals}\to \text{optimized arrangement}\backslash text\{objects\}\; +\; \backslash text\{constraints\}\; +\; \backslash text\{goals\}\; \backslash rightarrow\; \backslash text\{optimized\; arrangement\}$$

DesignGym proves this framework works for graphic design. The architecture is a foundation for any domain where arrangement matters.

---

🔗 Project Links

Resource	Link
🌍 Environment (HF Space)	DesignGym Environment Server
💻 GitHub Repo	canboyedits/DesignGym
🧠 SFT Trained Adapter	designgym2-sft-qwen05-lora
📓 GRPO Training Notebook	grpo_train_colab.ipynb
📓 SFT Training Notebook	SFT_training_script.ipynb
📓 Evaluation Notebook	evaluate_base_vs_sft.ipynb
📊 Training Logs	HF Training Job

---

🤔 Why Not Just Generate the Layout?

Because that's not how it works in the real world.

A good designer doesn't conjure the final poster from thin air. They start somewhere, step back, ask "what's wrong here?", make a targeted edit, look again, and repeat. The process is:

bad layout → structural choice → placement → refinement → polish → final design

DesignGym 2.0 formalizes that process as a reinforcement learning environment. The agent learns the workflow of design, not just the output.

This matters because layout improvement is an optimization problem, not a generation problem. And RL is the right tool for optimization.

---

🔬 Round 1 → Round 2: What Changed?

Area	DesignGym Round 1	DesignGym 2.0
Core goal	Optimize layouts with structured actions	Learn the process of design over multiple phases
Task style	Short-horizon layout refinement	Long-horizon planning + instruction following
Agent behavior	Local edit selection	Structure → placement → refinement → polish
Reward	Geometry + aesthetic deltas	Delta-aware, instruction-aware, phase-aware
Learning	Environment-ready foundation	SFT + GRPO training pipeline
Evaluation	Layout quality + validity	Base vs heuristic vs SFT vs GRPO comparison

Round 1 answered: Can layout design be a real RL environment?

Round 2 answers: Can an LLM learn to act like a designer?

---

🧩 The Environment: How It Works

State

Each design is a canvas of normalized elements. Every element $b_i$ has geometry:

$$b_i=(x_i,y_i,w_i,h_i),\text{where all values}\in [0,1]b\_i\; =\; (x\_i,\backslash ;\; y\_i,\backslash ;\; w\_i,\backslash ;\; h\_i),\; \backslash quad\; \backslash text\{where\; all\; values\}\; \backslash in\; [0,1]$$

A layout is:

$$L=\{b_1,b_2,\dots ,b_n\}L\; =\; \backslash \{b\_1,\; b\_2,\; \backslash dots,\; b\_n\backslash \}$$

The state given to the agent includes: task ID, step count, current score, best score so far, instruction score, phase score, metric vector, weakest metrics, focus elements, action history, full geometry, and current phase. The agent can reason not just about what the layout looks like but where it is in the design process.

The RL loop:

$$s_t\stackrel{a_t}{\to }{s}_{t+1},r_{t}s\_t\; \backslash ;\backslash xrightarrow\{\backslash ;a\_t\backslash ;\}\backslash ;\; s\_\{t+1\},\backslash ;\; r\_t$$

Actions

The action space spans both pixel-level and structural edits — because real design isn't just moving boxes:

Primitive actions: move, resize, align, distribute, snap, swap_z

Structural actions: apply_template, promote, reflow_group, anchor_to_region, finalize

For example:

• "Make the title louder" → promote
• "Clean up the spacing" → distribute or reflow_group
• "Move the CTA to the footer" → anchor_to_region
• "Choose a stronger layout" → apply_template

Hard Constraints

The feasible layout space is:

$$\mathcal{F}=\{L\mid L\text{ satisfies margin, size, ratio, and region constraints}\}\backslash mathcal\{F\}\; =\; \backslash \{L\; \backslash mid\; L\; \backslash text\{\; satisfies\; margin,\; size,\; ratio,\; and\; region\; constraints\}\backslash \}$$

Only $L \in \mathcal{F}$ are accepted. Invalid actions are rejected — forcing the agent to learn legal creativity.

---

🎯 Solving Aesthetics: The Math of "Good Design"

This is where DesignGym gets serious. Rather than asking "does it look good?" (subjective), we ask "what makes it measurably good?" (computable).

My research into computational aesthetics — from Birkhoff's 1933 aesthetic measure $M = O/C$ to modern Visual Moment Equilibrium models — confirmed that most design quality signals are mathematically expressible. DesignGym implements seven of them:

The Composite Score

$$U(L)=\sum _{k=1}^K{\lambda }_k{g}_k(L),g_k(L)\in [0,1],\sum _k{\lambda }_k=1U(L)\; =\; \backslash sum\_\{k=1\}^\{K\}\; \backslash lambda\_k\; \backslash ,\; g\_k(L),\; \backslash quad\; g\_k(L)\; \backslash in\; [0,1],\backslash ;\; \backslash sum\_k\; \backslash lambda\_k\; =\; 1$$

Each $g_k$ is an independent, interpretable aesthetic signal. Together they give a holistic quality score $U(L) \in [0,1]$.

---

1. Overlap — Do elements collide?

Exponential penalty for any intersection. Clean layouts score near 1.

---

2. Alignment — Do things line up intentionally?

$$g_{\text{align}}(L)=\frac{1}{\mathrm{\mid }\mathcal{Q}\mathrm{\mid }}\sum _{q\in \mathcal{Q}}\exp \text{\hspace{0.17em}⁣}(-\frac{d_q}{{\tau }_{\text{align}}})g\_\{\backslash text\{align\}\}(L)\; =\; \backslash frac\{1\}\{|\backslash mathcal\{Q\}|\}\; \backslash sum\_\{q\; \backslash in\; \backslash mathcal\{Q\}\}\; \backslash exp\backslash !\backslash left(-\backslash frac\{d\_q\}\{\backslash tau\_\{\backslash text\{align\}\}\}\backslash right)$$

$d_q$ is the distance from element anchors (left, center, right edges) to the nearest alignment guide. Lower distance → higher score.

---

3. Spacing — Is the rhythm intentional?

Coefficient of variation on gaps $\Delta$:

$$\mathrm{C}\mathrm{V}(\mathrm{\Delta })=\frac{\sigma (\mathrm{\Delta })}{\mu (\mathrm{\Delta })+ϵ},g_{\text{spacing}}(L)=\exp \text{\hspace{0.17em}⁣}(-\frac{\mathrm{C}\mathrm{V}(\mathrm{\Delta })}{{\tau }_{\text{space}}})\backslash mathrm\{CV\}(\backslash Delta)\; =\; \backslash frac\{\backslash sigma(\backslash Delta)\}\{\backslash mu(\backslash Delta)\; +\; \backslash epsilon\},\; \backslash qquad\; g\_\{\backslash text\{spacing\}\}(L)\; =\; \backslash exp\backslash !\backslash left(-\backslash frac\{\backslash mathrm\{CV\}(\backslash Delta)\}\{\backslash tau\_\{\backslash text\{space\}\}\}\backslash right)$$

Low variation = consistent rhythm = high score. This captures the difference between accidental spacing and deliberate structure.

---

4. Balance — Does visual weight feel stable?

Each element carries visual mass $m_i = a_i \cdot p_i$ (area × semantic importance). The center of mass:

$$c_x=\frac{\sum _i{m}_i{x}_i^{(c)}}{\sum _i{m}_i},c_y=\frac{\sum _i{m}_i{y}_i^{(c)}}{\sum _i{m}_i}c\_x\; =\; \backslash frac\{\backslash sum\_i\; m\_i\; x\_i^\{(c)\}\}\{\backslash sum\_i\; m\_i\},\; \backslash qquad\; c\_y\; =\; \backslash frac\{\backslash sum\_i\; m\_i\; y\_i^\{(c)\}\}\{\backslash sum\_i\; m\_i\}$$

Balance rewards layouts centered around the canvas midpoint:

$$g_{\text{balance}}(L)=\exp \text{\hspace{0.17em}⁣}(-\frac{\sqrt{(c_x-0.5{)}^2+(c_y-0.5{)}^2}}{{\tau }_{\text{bal}}})g\_\{\backslash text\{balance\}\}(L)\; =\; \backslash exp\backslash !\backslash left(-\backslash frac\{\backslash sqrt\{(c\_x\; -\; 0.5)^2\; +\; (c\_y\; -\; 0.5)^2\}\}\{\backslash tau\_\{\backslash text\{bal\}\}\}\backslash right)$$

Inspired by the Visual Moment Equilibrium model — treating layout as a physics problem where visual torques must cancel. This achieves Pearson $r = 0.942$ correlation with human perception benchmarks.

---

5. Hierarchy — Do big things matter more?

Visual salience per element:

$${\zeta }_i=\alpha \log (a_i+ϵ)-\beta y_i+\gamma f_i+\delta z_i\backslash zeta\_i\; =\; \backslash alpha\; \backslash log(a\_i\; +\; \backslash epsilon)\; -\; \backslash beta\; y\_i\; +\; \backslash gamma\; f\_i\; +\; \backslash delta\; z\_i$$

Hierarchy is measured by rank agreement with semantic importance $p_i$ via Spearman correlation:

$$g_{\text{hier}}(L)=\frac{1+{\rho }_S(p,\zeta )}{2}g\_\{\backslash text\{hier\}\}(L)\; =\; \backslash frac\{1\; +\; \backslash rho\_S(p,\backslash ,\; \backslash zeta)\}\{2\}$$

If the biggest element is also the most important, the layout looks right because it is right.

---

6. Reading Order — Does the eye flow correctly?

Given required reading relations $\mathcal{R} = {(i,j)}$:

$$g_{\text{read}}(L)=\frac{1}{\mathrm{\mid }\mathcal{R}\mathrm{\mid }}\sum _{(i,j)\in \mathcal{R}}\mathbf{1}\{i\prec j\}g\_\{\backslash text\{read\}\}(L)\; =\; \backslash frac\{1\}\{|\backslash mathcal\{R\}|\}\; \backslash sum\_\{(i,j)\backslash in\backslash mathcal\{R\}\}\; \backslash mathbf\{1\}\backslash \{i\; \backslash prec\; j\backslash \}$$

$i \prec j$ means element $i$ appears before $j$ in the intended scan path (F-pattern, Z-pattern, etc.).

---

7. Instruction Fit — Does the layout follow the brief?

Tasks have semantic placement goals (CTA in lower-right, masthead at top, etc.). Given target region center $r_i$ and element center $c_i$:

$$g_{\text{intent}}(L)=\frac{1}{n}\sum _i\exp \text{\hspace{0.17em}⁣}(-\frac{\mathrm{\parallel }{c}_i-r_i\mathrm{\parallel }}{{\tau }_{\text{intent}}})g\_\{\backslash text\{intent\}\}(L)\; =\; \backslash frac\{1\}\{n\}\; \backslash sum\_i\; \backslash exp\backslash !\backslash left(-\backslash frac\{\backslash |c\_i\; -\; r\_i\backslash |\}\{\backslash tau\_\{\backslash text\{intent\}\}\}\backslash right)$$

This is the bridge from pure geometry to design intention — an element can be perfectly aligned yet still be in the wrong place.

---

🏆 The Reward Function: Teaching Taste

This is the most important design decision in the whole project. A flat reward teaches nothing.

After SFT, nearly every action is valid JSON — so rewarding "valid JSON" gives GRPO a flat signal with no learning gradient. The reward had to be richer, more informative, and process-aware.

Delta-Sensitive Shaping

Let $S_t$, $I_t$, $P_t$, $B_t$ be layout score, instruction score, phase score, and best-so-far score at step $t$:

$$\mathrm{\Delta }{S}_t=S_t-S_{t-1},\mathrm{\Delta }{I}_t=I_t-I_{t-1},\mathrm{\Delta }{B}_t=\max (0,B_t-B_{t-1})\backslash Delta\; S\_t\; =\; S\_t\; -\; S\_\{t-1\},\; \backslash qquad\; \backslash Delta\; I\_t\; =\; I\_t\; -\; I\_\{t-1\},\; \backslash qquad\; \backslash Delta\; B\_t\; =\; \backslash max(0,\backslash ,\; B\_t\; -\; B\_\{t-1\})$$

With a clipped scaling function that makes small improvements legible:

$$\varphi (\mathrm{\Delta },\tau )=\mathrm{c}\mathrm{l}\mathrm{i}\mathrm{p}\text{\hspace{0.17em}⁣}(\frac{\mathrm{\Delta }}{\tau },-1,1)\backslash phi(\backslash Delta,\; \backslash tau)\; =\; \backslash mathrm\{clip\}\backslash !\backslash left(\backslash frac\{\backslash Delta\}\{\backslash tau\},\backslash ;\; -1,\backslash ;\; 1\backslash right)$$

The full shaped reward:

$$r_t=\mathrm{c}\mathrm{l}\mathrm{i}\mathrm{p}\text{\hspace{0.17em}⁣}(\underset{\text{base}}{\underbrace{0.03}}+\underset{\text{layout quality}}{\underbrace{0.35\varphi (\mathrm{\Delta }{S}_t,0.015)}}+\underset{\text{instruction fit}}{\underbrace{0.35\varphi (\mathrm{\Delta }{I}_t,0.020)}}+\underset{\text{phase progress}}{\underbrace{0.15\varphi (\mathrm{\Delta }{P}_t,0.025)}}+\underset{\text{best score}}{\underbrace{0.10\varphi (\mathrm{\Delta }{B}_t,0.015)}}+\underset{\text{env signal}}{\underbrace{0.05r_{\text{env}}}}+b_{\text{process}}-{\pi }_t,-1,1)r\_t\; =\; \backslash mathrm\{clip\}\backslash !\backslash Big(\backslash underbrace\{0.03\}\_\{\backslash text\{base\}\}\; +\; \backslash underbrace\{0.35\backslash ,\backslash phi(\backslash Delta\; S\_t,\backslash ;\; 0.015)\}\_\{\backslash text\{layout\; quality\}\}\; +\; \backslash underbrace\{0.35\backslash ,\backslash phi(\backslash Delta\; I\_t,\backslash ;\; 0.020)\}\_\{\backslash text\{instruction\; fit\}\}\; +\; \backslash underbrace\{0.15\backslash ,\backslash phi(\backslash Delta\; P\_t,\backslash ;\; 0.025)\}\_\{\backslash text\{phase\; progress\}\}\; +\; \backslash underbrace\{0.10\backslash ,\backslash phi(\backslash Delta\; B\_t,\backslash ;\; 0.015)\}\_\{\backslash text\{best\; score\}\}\; +\; \backslash underbrace\{0.05\backslash ,r\_\{\backslash text\{env\}\}\}\_\{\backslash text\{env\; signal\}\}\; +\; b\_\{\backslash text\{process\}\}\; -\; \backslash pi\_t,\backslash ;\; -1,\backslash ;\; 1\backslash Big)$$

Where $b_{\text{process}}$ is a phase-aware bonus and $\pi_t$ is a penalty for invalid, useless, or premature actions.

Process-Aware Reward: Diagnosing Before Acting

The reward checks not just whether the layout improved, but whether the agent chose the right kind of action for the current weakness:

Weak Metric	Preferred Actions
Overlap / crowding	move, resize, reflow_group
Spacing / rhythm	distribute, align, reflow_group
Hierarchy	promote, resize, apply_template
Instruction fit	anchor_to_region, promote
Early structure phase	apply_template
Late polish phase	align, snap, finalize

This teaches the agent to diagnose → choose relevantly → improve — not just make random valid edits.

Early Finalize Penalty

The agent must not give up early. finalize is only rewarded if:

$$S_t\ge 0.82\text{and}{I}_t\ge 0.72S\_t\; \backslash geq\; 0.82\; \backslash quad\; \backslash text\{and\}\; \backslash quad\; I\_t\; \backslash geq\; 0.72$$

Otherwise $\pi_{\text{finalize}} > 0$. This enforces long-horizon behavior and prevents the agent from prematurely declaring victory.

---

🎓 Training Pipeline: From Language to Design Policy

Base Model  →  Heuristic Planner  →  SFT Model  →  GRPO Model

Figure 2 — The heuristic planner solving an episode end-to-end. It diagnoses the weakest metric, picks a phase-appropriate action, applies it, and re-scores — generating the (state → action) pairs we use as SFT training data. This is how the agent gets a warm start without human labels.

Why SFT First?

The base model (Qwen 0.5B) understands design language but cannot speak the environment's action format. It says things like:

"Move the title higher and make the CTA stronger."

Semantically meaningful — but not executable. The environment needs:

{
  "action_type": "anchor_to_region",
  "element_id": "cta",
  "region": "lower_right"
}

SFT teaches the model the interface. The goal is not creativity — it's action correctness.

Result: valid_json_rate: 0% → valid_json_rate: 100%. That's not a fine-tune. That's a capability phase transition.

Figure 3 — SFT training evidence on Qwen-0.5B: loss converges cleanly, validity rates jump to 100%, and the action distribution learned by the model mirrors the heuristic teacher. After SFT the model can act in DesignGym; before SFT it cannot.

Why GRPO After?

Once the model can act, GRPO teaches it which valid action is better.

GRPO uses environment reward directly — no static labels, no human annotation on every trajectory. The loop:

1. Sample multiple candidate actions
2. Execute them in DesignGym
3. Score each with the verifier
4. Increase probability of higher-reward actions
5. Decrease probability of lower-reward actions

This works because DesignGym has verifiable rewards — the environment is the oracle. No reward model needed.

The learning story:

$$\text{Language Model}\stackrel{\text{SFT}}{\to }\text{Action Model}\stackrel{\text{GRPO}}{\to }\text{Design Policy}\backslash text\{Language\; Model\}\; \backslash ;\backslash xrightarrow\{\backslash ;\backslash text\{SFT\}\backslash ;\}\backslash ;\; \backslash text\{Action\; Model\}\; \backslash ;\backslash xrightarrow\{\backslash ;\backslash text\{GRPO\}\backslash ;\}\backslash ;\; \backslash text\{Design\; Policy\}$$

---

📊 Results: Evidence of Learning

Policy	Final Score	Instruction Score	Valid JSON	Early Finalize
Base Qwen 0.5B	0.6948	0.5360	0%	100%
SFT Qwen 0.5B	0.7101	0.6263	100%	0%
SFT @ Best-of-4	0.7057	0.6672	100%	0%
GRPO Qwen 0.5B	0.6717	0.5483	98%	67%
GRPO @ Best-of-4 ★	0.6781	0.5817	100%	17%

★ = shipped headline configuration. Base→Final pipeline gain on instruction score: +8.5%, on valid JSON: 0% → 100%, on premature finalizes: down 83%.

The most important result is the jump from 0% to 100% valid actions. That's the model crossing from "knows about design" to "can act in a design environment."

GRPO then learns which valid actions are better — a harder problem that continues to improve with more training. The infrastructure and reward signal are proven.

---

🛠️ Tasks Supported

poster_basic_v1 — Headline hierarchy, hero image placement, CTA placement, clean spacing, reading order.

editorial_cover_v1 — Masthead preservation, headline stack, visual balance, editorial hierarchy.

dense_flyer_v1 — Crowded layout repair, support group reflow, spacing under density, caption alignment.

Three very different design problems. A model that improves across all three has learned general layout reasoning, not template memorization.

---

🔮 How Big Can This Get?

The framework underlying DesignGym isn't about posters. It's about this general structure:

$$U(L)={\lambda }_1{g}_{\text{efficiency}}+{\lambda }_2{g}_{\text{safety}}+{\lambda }_3{g}_{\text{accessibility}}+{\lambda }_4{g}_{\text{aesthetic}}U(L)\; =\; \backslash lambda\_1\backslash ,\; g\_\{\backslash text\{efficiency\}\}\; +\; \backslash lambda\_2\backslash ,\; g\_\{\backslash text\{safety\}\}\; +\; \backslash lambda\_3\backslash ,\; g\_\{\backslash text\{accessibility\}\}\; +\; \backslash lambda\_4\backslash ,\; g\_\{\backslash text\{aesthetic\}\}$$

Swap the metrics. Swap the domain. The agent still learns to optimize arrangement through sequential decision-making.

Interior Design: empty room → zoning → furniture placement → spacing → style polish

VLSI Chip Placement: component placement → routing → thermal zones → signal integrity

Warehouse Logistics: shelf placement → picking paths → safety zones → density optimization

Hospital Layout: patient flow → emergency access → staff circulation → quiet zones

UI Design: information hierarchy → click paths → accessibility → responsive stability

The same RL loop. A different reward function. The canvas is always the problem, and the canvas is everywhere.

---

🏗️ Architecture

.
├── client.py                      # OpenEnv client interface
├── inference.py                   # Policy inference runner
├── models.py                      # Typed action/observation models
├── notebooks/
│   ├── grpo_train_colab.ipynb    # GRPO training ← start here
│   ├── SFT_training_script.ipynb # SFT training
│   └── evaluate_base_vs_sft_designgym2.ipynb
├── training/
│   ├── grpo_train.py              # GRPO training script
│   ├── generate_sft_data.py       # SFT data generation
│   └── run_grpo.sh                # Smoke test runner
├── server/
│   ├── app.py                     # FastAPI wrapper
│   ├── DesignGym_environment.py   # Core environment logic
│   ├── rewards.py                 # Reward functions
│   ├── phases.py                  # Phase-aware logic
│   └── requirements.txt
├── data/sft/                      # SFT train/eval data
├── assets/                        # Plots and diagrams
├── web/                           # Demo web UI
├── Dockerfile
├── pyproject.toml
├── openenv.yaml                   # OpenEnv manifest
└── README.md

---

⚡ OpenEnv Compatibility

DesignGym is fully OpenEnv-compatible: reset(), step(action), typed models, FastAPI server, Docker + HF Space deployment, deterministic seeded episodes.

---

🚀 Running It

Install:

pip install -e .
openenv validate
python server/app.py

Docker:

docker build -t designgym-env .
docker run --rm -p 8000:8000 designgym-env

Inference:

HF_TOKEN=your_token \
API_BASE_URL=https://router.huggingface.co/v1 \
MODEL_NAME=meta-llama/Llama-3.1-8B-Instruct:scaleway \
DESIGNGYM_TASK=poster_basic_v1 \
python inference.py

---

🧪 What's Next

• Image-Aware Reward — Saliency maps, OCR regions, protected focal zones
• Preference-Trained Reward Model — Learn from human pairwise layout comparisons
• Style-Conditioned Design — Luxury, editorial, minimal, corporate as goal inputs
• Interior DesignGym — Same framework extended to room/furniture layout
• Multi-Agent Critique — Designer agent proposes → Critic agent diagnoses → Designer improves
• Multi-Page Layout — Magazines, slide decks, reports, product catalogs

---

💡 The Bottom Line

Design is usually treated as subjective and unteachable by machine.

DesignGym proves that's not true. Many aspects of layout quality are computable, verifiable, and learnable. And because the underlying framework is general, the same approach extends to any domain where arrangement matters.

The final vision: models that don't just generate designs — but learn how to improve them, step by step, the way a skilled designer does.

A good designer does not just produce a layout.
A good designer repeatedly diagnoses, edits, compares, and improves.

DesignGym 2.0 teaches that process to a machine.

---

Built for the OpenEnv Hackathon · India 2026
Math rendered with KaTeX / MathJax