Spaces:
Running
Running
OrigamiRL — OpenEnv Hackathon Handoff Document
TL;DR
Build the first multi-turn RL environment where an LLM learns to generate origami folding instructions, verified by a computational origami simulator. Target the OpenEnv Hackathon (March 7-8, 2026, SF — $100K+ in prizes). Use OpenEnv spec + Unsloth GRPO for training. Dense verifiable rewards from origami geometry theorems (Kawasaki, Maekawa). No learned reward model needed.
Hackathon Context
- Event: OpenEnv Hackathon SF, hosted by Cerebral Valley + Shack15 + Meta/PyTorch
- Date: March 7-8, 2026 (happening NOW)
- Prize: $100K+ cash
- Teams: Up to 4 people
- Format: Build RL environments, post-train a base model
Judging Criteria
| Category | Weight | What Matters |
|---|---|---|
| Environment Innovation | 40% | Novel, creative, challenging. Does it meaningfully test agent behavior? |
| Storytelling | 30% | Clear problem explanation, engaging demo, easy to follow |
| Training Script Showing Improvement | 20% | Observable reward curves, before/after behavior |
| Reward and Training Pipeline Setup | 10% | Coherent reward logic, meaningful improvement in inference |
Key Sponsors to Impress
- Meta/PyTorch — OpenEnv creators, want environments using their spec
- Unsloth AI — GRPO training infra, ART (Agent Reinforcement Trainer). USE THEIR TOOLS.
- OpenPipe — ART trainer (frontend/backend split for GRPO). Also use.
- Patronus AI — Building "generative simulators" (auto-scaling RL environments). They care about curriculum difficulty scaling and verifiable rewards.
- Snorkel AI — "2026 is the year of environments." They care about data quality and environment diversity.
- Hugging Face — OpenEnv Hub, want environments deployed there
- Scale AI / Mercor — Agent evaluation, structured task environments
The Pitch (for judges)
"Spatial reasoning is the next frontier for LLM training — NeurIPS 2025 papers like OrigamiSpace showed that even GPT-5 fails at multi-step origami reasoning. But those are benchmarks, not training environments. We built OrigamiRL: the first multi-turn RL environment where an LLM agent learns to fold paper by outputting instructions, receiving geometric feedback, and improving through GRPO. Our reward function is fully verifiable — fold validity is checked against computational origami axioms, not an LLM judge. We built it on OpenEnv + Unsloth with a natural curriculum from single folds to full cranes."
Prior Work (What Exists, Where the Gaps Are)
1. OrigamiSpace (NeurIPS 2025 Spotlight)
- Paper: https://arxiv.org/abs/2511.18450
- What it is: Benchmark with 350 origami data instances (CP diagrams, folding processes, folded shapes). 4 evaluation tasks: Pattern Prediction, Multi-step Spatial Reasoning, Spatial Relationship Prediction, End-to-End CP Code Generation.
- Their compiler: Outputs detailed flattened diagrams with crease locations and stacking relationships, supports interactive simulation with MLLMs, provides comprehensive error feedback. Checks: syntax validity, geometric foldability, no self-intersections, Kawasaki's theorem, Maekawa's theorem.
- Their reward metrics for code gen: Hausdorff distance (shape similarity), dihedral angle distribution, bounding box aspect ratios, constraint satisfaction.
- Difficulty levels: Easy (3-9 steps), Medium (10-19 steps), Hard (20-30 steps)
- Gap: Single-turn only (LLM generates complete CP code in one shot). They mention RL exploration but it's not the focus. No multi-turn sequential folding.
2. GamiBench (Dec 2025)
- Paper: https://arxiv.org/abs/2512.22207
- What it is: 186 regular + 186 impossible 2D crease patterns with 3D folded shapes from 6 viewpoints. 3 VQA tasks.
- Gap: Evaluation-only, no training. Tests single-step spatial understanding.
3. SpatialThinker (NeurIPS 2025)
- Paper: https://arxiv.org/abs/2511.07403
- What it is: 3D-aware MLLM trained with RL using dense spatial rewards. Constructs scene graphs. Multi-objective reward with lexicographic gating.
- Key architecture to steal: Dense reward design with lexicographic ordering — format → count → accuracy → spatial. Nearly doubled RL training gains vs sparse rewards. Only needed 7K training samples with GRPO.
- Gap: Static scene understanding (objects on a table), not sequential physical transformations.
4. rigid-origami Gym (IJCAI 2023)
- Repo: https://github.com/belalugaX/rigid-origami
- Paper: "Automating Rigid Origami Design" (https://arxiv.org/abs/2211.13219)
- What it is: Gym environment where agent constructs crease pattern graphs on a board. Sparse rewards. Foldability validated by triangle intersection tests + kinematic rigidity model. Game terminates on non-foldable states.
- Gap: Classical RL agents (discrete grid actions), NOT LLMs generating text. Rigid-origami tessellations only, not traditional origami. No natural language.
5. The Unique Gap We Fill
Nobody has built a model that reasons about sequential 2D-to-3D geometric transformations with physical constraints through natural language instructions in a multi-turn RL training loop. Origami is uniquely hard because it requires tracking how a flat sheet's topology changes through a sequence of folds — mental rotation, spatial visualization, and perspective-taking all at once.
Environment Design
Architecture Overview
+---------------------------------------------------+
| OpenEnv Server |
| +-----------+ +----------+ +--------------+ |
| | State | | Action | | Reward | |
| | (FOLD JSON| | (LLM | | (Dense, | |
| | + target)| | output) | | verifiable) | |
| +-----------+ +----------+ +--------------+ |
| | | | |
| v v v |
| +-----------------------------------------------+|
| | Paper Geometry Engine (Python) ||
| | - Polygon state (Shapely) ||
| | - Fold operations (reflection across line) ||
| | - Kawasaki/Maekawa constraint checks ||
| | - Layer tracking ||
| | - FOLD format import/export ||
| +-----------------------------------------------+|
| | |
| v |
| +-----------------------------------------------+|
| | Three.js Visualizer (Demo only) ||
| | - 3D fold animation ||
| | - Strain heatmap ||
| | - Instruction stream ||
| +-----------------------------------------------+|
+---------------------------------------------------+
| ^
v |
+---------------------------------------------------+
| Unsloth ART / GRPO Trainer |
| - Qwen2.5-VL-7B or Qwen3-4B base model |
| - LoRA/QLoRA for efficient training |
| - Multi-turn rollouts |
+---------------------------------------------------+
OpenEnv Spec Compliance
Must implement these APIs:
class OrigamiEnv:
async def reset() -> Observation # New episode: flat paper + target
async def step(action) -> (Observation, reward, done, info)
async def state() -> State # Current paper geometry
async def close() # Cleanup
OpenEnv repo: https://github.com/meta-pytorch/OpenEnv
Install: pip install -e . then openenv init origami_env
State Space
@dataclass
class OrigamiState:
# Current paper geometry
vertices: List[Tuple[float, float]] # 2D vertex positions
edges: List[Tuple[int, int]] # Edge connectivity
edges_assignment: List[str] # 'M', 'V', 'B', 'F' (mountain/valley/boundary/flat)
edges_foldAngle: List[float] # -180 to 180 degrees
faces: List[List[int]] # Face vertex indices
layer_order: List[List[int]] # Face stacking order
# Episode context
target_crease_pattern: dict # Target FOLD JSON
target_shape_image: Optional[np.ndarray] # Target folded shape (for multimodal)
instruction_history: List[str] # Previous instructions
step_count: int
max_steps: int
This maps directly to the FOLD format (JSON-based, used by all origami software):
{
"vertices_coords": [[0,0], [1,0], [1,1], [0,1]],
"edges_vertices": [[0,1], [1,2], [2,3], [3,0]],
"edges_assignment": ["B", "B", "B", "B"],
"edges_foldAngle": [0, 0, 0, 0],
"faces_vertices": [[0, 1, 2, 3]]
}
FOLD spec: https://github.com/edemaine/fold FOLD JS library: https://edemaine.github.io/fold/
Action Space
The LLM outputs a JSON action:
{
"instruction": "Fold the top edge down to meet the bottom edge",
"fold_line": [[0, 0.5], [1, 0.5]],
"fold_angle": -180,
"assignment": "V"
}
The instruction field is natural language (what we're training the model to produce well). The geometric fields are the verifiable representation. During training, the model outputs both; for the final demo, the NL instruction is the star.
Alternative simpler action (for early iterations):
{
"instruction": "Valley fold along the horizontal center line",
"fold_type": "valley",
"fold_axis": "horizontal",
"fold_position": 0.5
}
Reward Function — Dense, Multi-Objective, Lexicographically Gated
Inspired by SpatialThinker's design. Rewards are computed in order; later rewards only apply if earlier gates pass.
def compute_reward(state, action, new_state, target) -> dict:
rewards = {}
# LEVEL 1: Format (gate for everything else)
# Does the output parse into a valid fold operation?
rewards['format'] = 1.0 if parseable(action) else 0.0
if rewards['format'] == 0:
return rewards # Stop here
# LEVEL 2: Local Geometric Validity
# Kawasaki's theorem: sector angles at each interior vertex sum to 2pi
kawasaki_valid = check_kawasaki(new_state)
# Maekawa's theorem: |M - V| = 2 at each interior vertex
maekawa_valid = check_maekawa(new_state)
# No self-intersection
no_intersection = check_no_self_intersection(new_state)
rewards['validity'] = (kawasaki_valid + maekawa_valid + no_intersection) / 3.0
if rewards['validity'] < 0.5:
return rewards # Stop here
# LEVEL 3: Physical Feasibility
# Can this fold actually be performed given layer stack?
layer_consistent = check_layer_ordering(new_state)
fold_achievable = check_fold_angle_feasible(new_state)
rewards['feasibility'] = (layer_consistent + fold_achievable) / 2.0
# LEVEL 4: Progress Toward Target (Dense)
# Crease pattern graph similarity
cp_similarity = crease_pattern_similarity(new_state, target)
# Fold angle distribution match
angle_similarity = fold_angle_distribution_match(new_state, target)
# Bounding box aspect ratio match
bbox_similarity = bounding_box_similarity(new_state, target)
rewards['progress'] = 0.4 * cp_similarity + 0.4 * angle_similarity + 0.2 * bbox_similarity
# LEVEL 5: Completion Bonus
if shape_matches_target(new_state, target, tolerance=0.05):
rewards['completion'] = 10.0
# LEVEL 6: Efficiency
rewards['efficiency'] = -0.01 # Small step penalty to encourage fewer folds
# Total
rewards['total'] = (
0.1 * rewards['format'] +
0.2 * rewards['validity'] +
0.1 * rewards['feasibility'] +
0.5 * rewards['progress'] +
rewards.get('completion', 0) +
rewards['efficiency']
)
return rewards
Key Origami Theorems for Verification
These are the verifiable constraints — the "unit tests" of origami:
Kawasaki's Theorem: At any interior vertex of a flat-foldable crease pattern, the alternating sum of sector angles equals zero (equivalently, they sum to 2pi on each side). NECESSARY condition for flat-foldability.
Maekawa's Theorem: At any interior vertex, the number of mountain folds minus valley folds equals +/-2. |M - V| = 2.
No self-intersection: Faces cannot penetrate each other during folding.
Euler's formula for planar graphs: V - E + F = 2 (sanity check on graph structure).
Huzita-Hatori axioms: The 7 axioms defining all possible single-fold operations (point-to-point, point-to-line, line-to-line, etc.). These define the VALID action space.
Curriculum Design
| Level | Folds | Examples | Complexity |
|---|---|---|---|
| 1 | 1 | Valley fold in half, mountain fold corner | Single fold validity |
| 2 | 2-3 | Paper airplane nose, triangle fold | Sequential dependency |
| 3 | 4-6 | Simple boat, fortune teller | Multi-step with symmetry |
| 4 | 7-12 | Paper airplane (full), jumping frog | Longer horizon planning |
| 5 | 13-20 | Crane, lily | Complex spatial tracking |
For the hackathon, focus on Levels 1-3. Even showing reward improvement on Level 1-2 is a strong result.
Core Implementation: Python Geometry Engine
This is the MOST IMPORTANT piece. Pure Python, no JS dependencies.
import numpy as np
from shapely.geometry import Polygon, LineString, MultiPolygon
from shapely.ops import split
from typing import List, Tuple, Dict
import json
class PaperState:
"""Represents the current state of the origami paper."""
def __init__(self, size: float = 1.0):
# Start with a unit square
self.regions = [Polygon([(0,0), (size,0), (size,size), (0,size)])]
self.fold_history = []
self.crease_lines = []
self.crease_assignments = [] # 'M' or 'V'
self.crease_angles = []
self.layer_order = [0] # Stack order of regions
def apply_fold(self, fold_line: LineString, angle: float, assignment: str) -> dict:
"""
Apply a fold operation. Returns dict with validity info.
fold_line: Shapely LineString defining the fold axis
angle: fold angle in degrees (-180 to 180)
assignment: 'M' (mountain) or 'V' (valley)
"""
result = {'valid': True, 'errors': []}
# 1. Split regions by fold line
new_regions = []
for region in self.regions:
if fold_line.intersects(region):
parts = split(region, fold_line)
new_regions.extend(parts.geoms)
else:
new_regions.append(region)
# 2. Determine which side folds (based on assignment)
folding_side = []
staying_side = []
for region in new_regions:
centroid = region.centroid
side = self._point_side(centroid, fold_line)
if side > 0:
folding_side.append(region)
else:
staying_side.append(region)
# 3. Reflect folding regions across fold line
reflected = [self._reflect_polygon(r, fold_line) for r in folding_side]
# 4. Update state
self.regions = staying_side + reflected
self.crease_lines.append(fold_line)
self.crease_assignments.append(assignment)
self.crease_angles.append(angle)
self.fold_history.append({
'line': list(fold_line.coords),
'angle': angle,
'assignment': assignment
})
# 5. Update layer order
self._update_layer_order(staying_side, reflected)
return result
def _reflect_polygon(self, poly: Polygon, line: LineString) -> Polygon:
"""Reflect a polygon across a line."""
coords = list(poly.exterior.coords)
reflected_coords = [self._reflect_point(p, line) for p in coords]
return Polygon(reflected_coords)
def _reflect_point(self, point: tuple, line: LineString) -> tuple:
"""Reflect a point across a line."""
p = np.array(point[:2])
l1 = np.array(line.coords[0])
l2 = np.array(line.coords[1])
d = l2 - l1
d = d / np.linalg.norm(d)
# Reflection formula: p' = p - 2(p-l1).n * n where n is normal to line
n = np.array([-d[1], d[0]])
v = p - l1
return tuple(p - 2 * np.dot(v, n) * n)
def _point_side(self, point, line: LineString) -> float:
"""Returns positive if point is on left side of line, negative if right."""
p = np.array([point.x, point.y])
l1 = np.array(line.coords[0])
l2 = np.array(line.coords[1])
return float(np.cross(l2 - l1, p - l1))
def _update_layer_order(self, staying, reflected):
"""Update the layer stacking order after a fold."""
self.layer_order = list(range(len(staying))) + \
list(range(len(staying), len(staying) + len(reflected)))
def to_fold_json(self) -> dict:
"""Export current state as FOLD format JSON."""
vertices = set()
for line in self.crease_lines:
for coord in line.coords:
vertices.add(tuple(round(c, 10) for c in coord))
# Add boundary vertices
for region in self.regions:
for coord in region.exterior.coords:
vertices.add(tuple(round(c, 10) for c in coord[:2]))
vertices = sorted(list(vertices))
vertex_map = {v: i for i, v in enumerate(vertices)}
edge_set = set()
edges_list = []
assignments_list = []
angles_list = []
# Add crease edges
for i, line in enumerate(self.crease_lines):
c = [tuple(round(x, 10) for x in coord) for coord in line.coords]
edge = tuple(sorted([vertex_map[c[0]], vertex_map[c[1]]]))
if edge not in edge_set:
edge_set.add(edge)
edges_list.append(list(edge))
assignments_list.append(self.crease_assignments[i])
angles_list.append(self.crease_angles[i])
return {
'vertices_coords': [list(v) for v in vertices],
'edges_vertices': edges_list,
'edges_assignment': assignments_list,
'edges_foldAngle': angles_list,
}
class OrigamiVerifier:
"""Verifiable reward functions based on origami theorems."""
@staticmethod
def check_kawasaki(state: PaperState) -> bool:
"""Kawasaki's theorem: alternating sum of angles at each interior vertex = 0."""
fold_json = state.to_fold_json()
vertices = fold_json['vertices_coords']
edges = fold_json['edges_vertices']
for v_idx in range(len(vertices)):
v = vertices[v_idx]
incident_edges = [e for e in edges if v_idx in e]
if len(incident_edges) < 4:
continue # Need degree-4+ for Kawasaki
# Calculate sector angles
angles = []
for e in incident_edges:
other = e[1] if e[0] == v_idx else e[0]
other_v = vertices[other]
angle = np.arctan2(other_v[1] - v[1], other_v[0] - v[0])
angles.append(angle)
angles.sort()
sector_angles = []
for i in range(len(angles) - 1):
sector_angles.append(angles[i+1] - angles[i])
sector_angles.append(2*np.pi - (angles[-1] - angles[0]))
# Kawasaki: alternating sum should be ~0
if len(sector_angles) >= 4:
alt_sum = sum(sector_angles[::2]) - sum(sector_angles[1::2])
if abs(alt_sum) > 0.01:
return False
return True
@staticmethod
def check_maekawa(state: PaperState) -> bool:
"""Maekawa's theorem: |M - V| = 2 at each interior vertex."""
fold_json = state.to_fold_json()
vertices = fold_json['vertices_coords']
edges = fold_json['edges_vertices']
assignments = fold_json['edges_assignment']
for v_idx in range(len(vertices)):
incident = [(i, e) for i, e in enumerate(edges) if v_idx in e]
m_count = sum(1 for i, _ in incident if i < len(assignments) and assignments[i] == 'M')
v_count = sum(1 for i, _ in incident if i < len(assignments) and assignments[i] == 'V')
if m_count + v_count >= 4: # Interior vertex with folds
if abs(m_count - v_count) != 2:
return False
return True
@staticmethod
def crease_pattern_similarity(state: PaperState, target_fold_json: dict) -> float:
"""Compare current crease pattern to target. Returns 0-1 similarity."""
current = state.to_fold_json()
n_current = len(current.get('edges_vertices', []))
n_target = len(target_fold_json.get('edges_vertices', []))
if n_target == 0:
return 1.0 if n_current == 0 else 0.0
edge_count_sim = 1.0 - abs(n_current - n_target) / max(n_target, 1)
edge_count_sim = max(0, edge_count_sim)
current_assignments = current.get('edges_assignment', [])
target_assignments = target_fold_json.get('edges_assignment', [])
c_m = current_assignments.count('M')
c_v = current_assignments.count('V')
t_m = target_assignments.count('M')
t_v = target_assignments.count('V')
total = max(t_m + t_v, 1)
assign_sim = 1.0 - (abs(c_m - t_m) + abs(c_v - t_v)) / (2 * total)
assign_sim = max(0, assign_sim)
return 0.5 * edge_count_sim + 0.5 * assign_sim
OpenEnv Environment Wrapper
# origami_env/server.py
from openenv.core import Environment
from paper_engine import PaperState, OrigamiVerifier
from shapely.geometry import LineString
import json
class OrigamiEnvironment(Environment):
def __init__(self, targets_dir="targets/", max_steps=20):
self.targets_dir = targets_dir
self.max_steps = max_steps
self.paper = None
self.target = None
self.step_count = 0
async def reset(self, target_id=None):
self.paper = PaperState(size=1.0)
self.target = self._load_target(target_id)
self.step_count = 0
return self._get_observation()
async def step(self, action):
self.step_count += 1
# Parse action
try:
fold_line = LineString(action['fold_line'])
angle = action['fold_angle']
assignment = action['assignment']
except (KeyError, Exception):
reward = {'format': 0, 'total': -0.1}
return self._get_observation(), reward, False, {'error': 'parse_failed'}
# Apply fold
result = self.paper.apply_fold(fold_line, angle, assignment)
# Compute rewards
reward = self._compute_reward(result)
# Check termination
done = (
self.step_count >= self.max_steps or
reward.get('completion', 0) > 0
)
return self._get_observation(), reward, done, {}
async def state(self):
return {
'paper': self.paper.to_fold_json(),
'target': self.target,
'step': self.step_count,
'fold_history': self.paper.fold_history
}
def _compute_reward(self, fold_result):
rewards = {}
rewards['format'] = 1.0
kawasaki = OrigamiVerifier.check_kawasaki(self.paper)
maekawa = OrigamiVerifier.check_maekawa(self.paper)
rewards['validity'] = (float(kawasaki) + float(maekawa)) / 2.0
rewards['progress'] = OrigamiVerifier.crease_pattern_similarity(
self.paper, self.target
)
if rewards['progress'] > 0.95:
rewards['completion'] = 10.0
rewards['efficiency'] = -0.01
rewards['total'] = (
0.1 * rewards['format'] +
0.2 * rewards['validity'] +
0.6 * rewards['progress'] +
rewards.get('completion', 0) +
rewards['efficiency']
)
return rewards
def _get_observation(self):
return {
'paper_state': self.paper.to_fold_json(),
'target': self.target,
'step': self.step_count,
'instruction_history': [str(f['line']) for f in self.paper.fold_history]
}
def _load_target(self, target_id):
if target_id:
with open(f"{self.targets_dir}/{target_id}.fold") as f:
return json.load(f)
# Default: simple valley fold in half
return {
'vertices_coords': [[0,0], [1,0], [1,1], [0,1], [0,0.5], [1,0.5]],
'edges_vertices': [[0,1], [1,2], [2,3], [3,0], [4,5]],
'edges_assignment': ['B', 'B', 'B', 'B', 'V'],
'edges_foldAngle': [0, 0, 0, 0, -180],
}
Training Script (Unsloth GRPO)
# train.py
from unsloth import FastLanguageModel
from trl import GRPOConfig, GRPOTrainer
import torch
# Load model
model, tokenizer = FastLanguageModel.from_pretrained(
model_name="unsloth/Qwen2.5-7B-Instruct",
max_seq_length=4096,
load_in_4bit=True,
)
# Add LoRA
model = FastLanguageModel.get_peft_model(
model,
r=32,
target_modules=["q_proj", "k_proj", "v_proj", "o_proj",
"gate_proj", "up_proj", "down_proj"],
lora_alpha=32,
lora_dropout=0,
use_gradient_checkpointing="unsloth",
)
# Reward function
def origami_reward(completions, prompts):
"""Compute rewards for a batch of completions."""
rewards = []
for completion in completions:
try:
action = parse_fold_action(completion)
paper = PaperState()
result = paper.apply_fold(action['fold_line'], action['angle'], action['assignment'])
r = compute_reward(paper, target)
rewards.append(r['total'])
except Exception:
rewards.append(-0.1)
return rewards
# GRPO Config
config = GRPOConfig(
output_dir="origami-grpo",
num_train_epochs=3,
per_device_train_batch_size=4,
gradient_accumulation_steps=4,
learning_rate=5e-6,
max_completion_length=512,
num_generations=8,
temperature=1.0,
logging_steps=1,
)
dataset = load_origami_prompts()
trainer = GRPOTrainer(
model=model,
config=config,
train_dataset=dataset,
reward_funcs=[origami_reward],
tokenizer=tokenizer,
)
trainer.train()
Visualization (Demo Only — Not in Training Loop)
Options
- Origami Simulator — https://github.com/amandaghassaei/OrigamiSimulator — Three.js, accepts FOLD files, shows folding animation with strain visualization
- PackCAD — https://packcad.com/ — Web-based, SVG crease patterns, rigid folding simulation
- Custom Three.js — Simpler but more control
Demo UI Layout
+----------------------+----------------------+
| Instruction Stream | 3D Fold Viewer |
| | |
| Step 1: Valley fold | [Three.js canvas] |
| along center [OK] | |
| | Paper animating |
| Step 2: Fold top | fold by fold |
| corners to center | |
| | |
+----------------------+----------------------+
| Reward Dashboard |
| Format: ========== 1.0 |
| Validity: ========.. 0.8 |
| Progress: ======.... 0.6 |
| Total: =======... 0.72 |
| |
| [Reward curve over training steps] |
+----------------------------------------------+
Key Libraries and Resources
| Tool | Purpose | Link |
|---|---|---|
| OpenEnv | Environment framework | https://github.com/meta-pytorch/OpenEnv |
| Unsloth | GRPO training | https://github.com/unslothai/unsloth |
| OpenPipe ART | Multi-turn RL trainer | https://github.com/OpenPipe/ART |
| FOLD format | Origami data structure | https://github.com/edemaine/fold |
| Rabbit Ear | JS origami library | https://github.com/rabbit-ear/rabbit-ear |
| Origami Simulator | 3D visualization | https://github.com/amandaghassaei/OrigamiSimulator |
| PackCAD | Folding simulation | https://packcad.com/ |
| Shapely | Python geometry | pip install shapely |
| rigid-origami gym | Reference gym env | https://github.com/belalugaX/rigid-origami |
Papers to Cite
- OrigamiSpace: https://arxiv.org/abs/2511.18450
- GamiBench: https://arxiv.org/abs/2512.22207
- SpatialThinker: https://arxiv.org/abs/2511.07403
- Automating Rigid Origami Design: https://arxiv.org/abs/2211.13219
- FOLD format spec: https://github.com/edemaine/fold/blob/main/doc/spec.md
Priority Build Order
- Python geometry engine — PaperState class with fold operations and FOLD export
- Verifier functions — Kawasaki, Maekawa, similarity metrics
- OpenEnv wrapper — step/reset/state API
- Simple targets — Hand-create 5-10 Level 1-2 targets as .fold files
- Training script — Wire up Unsloth GRPO with reward function
- Run training — Even on small model, get reward curves
- Three.js visualizer — For demo only, not in training loop
- Before/after demo — Show base model vs trained model outputs
- Polish presentation narrative
Narrative for Judges
The story arc:
- "LLMs are great at text but terrible at spatial reasoning"
- "Origami is the perfect testbed — it's sequential, physical, and verifiable"
- "NeurIPS 2025 showed even GPT-5 fails at origami benchmarks, but nobody built a TRAINING environment"
- "We built OrigamiRL — the first multi-turn RL environment for origami instruction generation"
- "Our rewards come from math theorems, not vibes — Kawasaki's theorem is our unit test"
- "Watch the model go from generating paper-tearing nonsense to valid fold sequences"
- "This generalizes to any domain where LLMs need to output structured physical instructions"