Run Detail
completedinklingRecorded for these videos
27:18Gemini 4 Hydrogen: Cheaper Tokens, More Expensive Answers?
Nov 13, 2026 · YouTube
18:40ERNIE 5.5 Flash Preview vs GLM 5.3 Flash: Baidu's new model is very impressive!
Nov 11, 2026 · YouTube
36:22Fable 5.2 robbing me blind, plus: Nex AGI's N2.6 vs GLM 5.3 Flash
Nov 11, 2026 · YouTube
14:03Gemini 4 Carbon: Can it handle my challenges? (First look with one-shot coding tests)
Nov 10, 2026 · YouTube
47:51Ranking major U.S. Open-Weights Models. (Where does Ripple 65B fit in?)
Nov 6, 2026 · YouTube
10:57"Crouton Alpha": the latest super-efficient coding model by Meta?
Nov 3, 2026 · YouTube
38:58Testing Particle-1: a post-trained DeepSeek V4.1 Flash specializing in coding and efficiency
Oct 28, 2026 · YouTube
22:14GPT-6.1 Terra Pro vs Terra: How Much Better Is Pro?
Oct 27, 2026 · YouTube
29:55Kimi K3.1 Pro Looked Incredible. Then I Kept Testing.
Oct 26, 2026 · YouTube
31:28Is this company reselling GPT Sol 6.1 at a loss (for non-agentic/text-only)?🤔 Is this sustainable?
Oct 20, 2026 · YouTube
17:58Nemotron 3.5 Super VL vs Opus 5.5: Testing NVIDIA’s new coding juggernaut
Oct 15, 2026 · YouTube
16:04Testing a *massive* new open-weights model 🤯: Muse Spark Open (vs. Nemotron, Opus 5.5, and more)
Oct 15, 2026 · YouTube
16:43Gemini 4 Argon: Great 🐈 Animation, but a broken escalator. (Coding challenge vs Opus 5.5, Sol 6.1)
Oct 13, 2026 · YouTube
16:37Meta's new "Muse Wonder" AI is impressive... but can it compete with Anthropic's models?
Oct 12, 2026 · YouTube
11:12WOW... Haiku 5.5 is very impressive. RIP OpenAI?
Oct 7, 2026 · YouTube
22:47Mistral Large 4 Is Cheap. But Is It Good Enough to Compete?
Oct 6, 2026 · YouTube
22:02Is Pareto 26.10 Preview Just Routing to GPT Sol? I Tested It Against Sol 6.1 Pro
Oct 1, 2026 · YouTube
11:22I Tested Sonnet 5.5 Against Opus 5.5. Is It Actually Cheaper?
Sep 28, 2026 · YouTube
30:00Did Elon Musk's team "train the gay away"... and make Grok 4.7 worse?
Sep 26, 2026 · YouTube
19:21I Tested the Stealth "Space Bunny Alpha" Model Before It Went Offline
Sep 23, 2026 · YouTube
10:58So... how much better is Claude Opus 5.5 vs. GPT-6 Sol, really?
Sep 23, 2026 · YouTube
9:38Claude Opus 5.5... the BEST new model for coding!! 🤩
Sep 22, 2026 · YouTube
29:00Grok 4.7: improved, but GLM 5.3 FlashX beat it anyway (benchmark against Gemini, Sol, etc.)
Sep 22, 2026 · YouTube
Provider
openrouter
Challenge Version
v1.0
Turns
1
Duration
80.7s
Total Tokens
12,710
Input Tokens
423
Output Tokens
12,287
Reasoning Tokens
8,225
Reasoning Effort
default
Est. Cost
$0.0502
Started
11/6/2026, 1:16:09 PM
OR Provider
Together
Finish Reason
stop
Generation ID
gen-1793970968-697vFzC5pOVYpQd5LyYq
Turns (1)
Turn #1
423 in12,287 out8,225 reasoning12,710 total80.6s
user
You write simulations where the interesting behavior is supposed to emerge rather than be animated by hand.
Build me a single HTML page: a side-view escalator carrying 15 to 20 people. Then the escalator reverses, at high speed.
The build
- Side view. 15 to 20 figures standing on the steps, riding normally before anything goes wrong.
- A control I can press to throw it into reverse, and press again to put it back. Reversal happens fast enough to take everyone off their feet.
- What follows comes out of the simulation. People stumble, collide, slide, and pile up against each other; a figure that is down is an obstacle to the ones arriving behind it.
- Figures get up again when they have the room and the footing.
- No scripted disaster. No keyframed pile, no timeline, no figure that falls because the clock said so. Every figure runs the same rules. If you special-case anything, say so in the notes.
- The art is yours. Stick figures are fine if they move well.
House rules
- One file. Everything inline — no CDN, no external stylesheet, font, script or image.
data:URIs are fine. - No libraries. No physics engine — write your own.
- No network at runtime.
- No
localStorage,sessionStorage, cookies orindexedDB— sandboxed frame, they throw. - Return the file as exactly one fenced
htmlblock.
Answer in exactly these sections
The model
One paragraph, before the file: how a person is represented, what makes one lose balance, and what happens when two of them occupy the same place.
The page
The single fenced html block.
What it actually does
Having written it, what does the page do when the escalator reverses? Name anything you special-cased or nudged. Say what it does badly — I am going to press the button and watch.
assistant
The model
Each figure is a point with a radius, velocity vector, and one of four states—standing, falling, down, or recovering. While standing, its velocity is pulled toward the escalator’s velocity; if the escalator suddenly reverses, the velocity gap exceeds a threshold and the figure immediately enters falling, where gravity and air resistance take over. Two figures that overlap are pushed apart along the line connecting their centers; if a standing figure is pushed by one that is falling or down, it also enters falling. A down figure uses a larger radius, lies horizontally, and blocks anyone sliding into it. It stays down until a shared timer expires and there is clear space around it, then it transitions through recovering back to standing. Every figure runs the same update loop; the only special-casing is the initial placement on steps and the button that flips the escalator velocity vector.
The page
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<meta name="viewport" content="width=device-width, initial-scale=1.0">
<title>Escalator Reversal</title>
<style>
* { margin: 0; padding: 0; box-sizing: border-box; }
body {
background: #1a1a1e;
color: #e8e8e8;
font-family: system-ui, -apple-system, sans-serif;
display: flex;
flex-direction: column;
align-items: center;
min-height: 100vh;
}
h1 { margin-top: 24px; font-weight: 300; letter-spacing: 0.05em; font-size: 1.6rem; }
p.subtitle { color: #888; margin: 6px 0 18px; font-size: 0.9rem; }
#wrap {
position: relative;
border: 1px solid #333;
border-radius: 8px;
overflow: hidden;
box-shadow: 0 20px 60px rgba(0,0,0,0.6);
}
canvas { display: block; background: linear-gradient(180deg, #23232a 0%, #18181b 100%); }
#controls {
margin: 18px 0 30px;
display: flex; gap: 12px; align-items: center;
}
button {
background: #c44;
color: #fff;
border: none;
padding: 12px 28px;
border-radius: 6px;
font-size: 1rem;
cursor: pointer;
box-shadow: 0 4px 14px rgba(200,60,60,0.35);
transition: background 0.15s, transform 0.05s;
}
button:hover { background: #e55; }
button:active { transform: translateY(1px); }
button.reversed { background: #4a8; box-shadow: 0 4px 14px rgba(60,160,100,0.35); }
#status {
font-variant-numeric: tabular-nums;
font-size: 0.85rem;
color: #aaa;
min-width: 220px;
text-align: center;
}
.note {
max-width: 720px;
padding: 0 24px 40px;
color: #999;
font-size: 0.85rem;
line-height: 1.5;
}
</style>
</head>
<body>
<h1>Escalator Reversal</h1>
<p class="subtitle">Side view — 18 figures — emergent physics</p>
<div id="wrap">
<canvas id="c" width="800" height="600"></canvas>
</div>
<div id="controls">
<button id="btn">Reverse Escalator</button>
<div id="status">State: Normal (up)</div>
</div>
<div class="note">
Press the button to throw the escalator into high-speed reverse. Press again to restore.
Figures fall based on velocity shock and collisions; down figures become obstacles.
Recovery only happens when there is open space.
</div>
<script>
const canvas = document.getElementById('c');
const ctx = canvas.getContext('2d');
const btn = document.getElementById('btn');
const status = document.getElementById('status');
// Escalator parameters
let vEsc = { x: 0, y: -1.6 }; // moving up slowly
let reversed = false;
// People
const COUNT = 18;
const people = [];
function initPeople() {
people.length = 0;
for (let i = 0; i < COUNT; i++) {
const x = 280 + (i % 4) * 70 + Math.random() * 30;
const y = 160 + Math.floor(i / 4) * 22 + Math.random() * 8;
people.push({
x, y,
vx: 0, vy: vEsc.y,
state: 'STANDING', // STANDING | FALLING | DOWN | RECOVERING
timer: 0,
r: 10
});
}
}
initPeople();
// Steps (visual only, move with escalator)
const steps = [];
for (let i = 0; i < 14; i++) {
steps.push({ y: 130 + i * 26 });
}
function updateSteps() {
for (const s of steps) {
s.y += vEsc.y;
if (vEsc.y < 0 && s.y < 100) s.y += 14 * 26;
if (vEsc.y > 0 && s.y > 520) s.y -= 14 * 26;
}
}
// Physics constants
const GRAVITY = 0.45;
const AIR_RES = 0.97;
const BALANCE_THRESHOLD = 4.0;
const R_STAND = 10;
const R_FALL = 12;
const R_DOWN = 18;
const R_RECOVER = 10;
function updatePhysics() {
// Update escalator velocity effect on standing people
for (const p of people) {
if (p.state === 'STANDING') {
// Pull toward escalator velocity
p.vx += (vEsc.x - p.vx) * 0.25;
p.vy += (vEsc.y - p.vy) * 0.25;
// Sudden reversal check
if (Math.abs(vEsc.y - p.vy) > BALANCE_THRESHOLD || Math.abs(vEsc.x - p.vx) > BALANCE_THRESHOLD) {
p.state = 'FALLING';
p.vy = vEsc.y * 0.4 + 3.5; // stumble downward
p.vx = vEsc.x + (Math.random() - 0.5) * 2;
p.timer = 0;
p.r = R_FALL;
}
}
}
// Apply dynamics per state
for (const p of people) {
if (p.state === 'FALLING') {
p.vy += GRAVITY;
p.vx *= AIR_RES;
p.vy *= AIR_RES;
p.x += p.vx;
p.y += p.vy;
p.timer++;
p.r = R_FALL;
// Transition to DOWN after falling for a while or hitting bottom
if (p.timer > 35 || p.y > 500) {
p.state = 'DOWN';
p.vx = 0;
p.vy = 0;
p.timer = 0;
p.r = R_DOWN;
}
} else if (p.state === 'DOWN') {
p.vx = 0;
p.vy = 0;
p.timer++;
p.r = R_DOWN;
// Recover only if timer passed and space is clear
if (p.timer > 90) {
let clear = true;
for (const o of people) {
if (o === p) continue;
const dx = o.x - p.x;
const dy = o.y - p.y;
const dist = Math.sqrt(dx*dx + dy*dy);
if (dist < (p.r + o.r + 6)) {
clear = false;
break;
}
}
if (clear) {
p.state = 'RECOVERING';
p.timer = 0;
p.r = R_RECOVER;
}
}
} else if (p.state === 'RECOVERING') {
p.timer++;
p.r = R_RECOVER;
// Slowly stand back up
p.vx += (vEsc.x - p.vx) * 0.15;
p.vy += (vEsc.y - p.vy) * 0.15;
p.x += p.vx;
p.y += p.vy;
if (p.timer > 35) {
p.state = 'STANDING';
p.timer = 0;
p.r = R_STAND;
p.vx = vEsc.x;
p.vy = vEsc.y;
}
} else if (p.state === 'STANDING') {
p.x += p.vx;
p.y += p.vy;
p.r = R_STAND;
}
}
// Boundary containment (soft walls)
for (const p of people) {
if (p.x < 240) { p.x = 240; p.vx *= -0.3; }
if (p.x > 560) { p.x = 560; p.vx *= -0.3; }
if (p.y < 120) { p.y = 120; p.vy *= -0.3; }
if (p.y > 540) { p.y = 540; p.vy *= -0.3; }
}
// Collision resolution
for (let i = 0; i < people.length; i++) {
for (let j = i + 1; j < people.length; j++) {
const a = people[i];
const b = people[j];
const dx = b.x - a.x;
const dy = b.y - a.y;
const dist = Math.sqrt(dx*dx + dy*dy);
const minDist = a.r + b.r;
if (dist < minDist && dist > 0.001) {
const overlap = minDist - dist;
const nx = dx / dist;
const ny = dy / dist;
// Push apart
a.x -= nx * overlap * 0.5;
a.y -= ny * overlap * 0.5;
b.x += nx * overlap * 0.5;
b.y += ny * overlap * 0.5;
// Fall triggers
if (a.state === 'STANDING' && (b.state === 'FALLING' || b.state === 'DOWN')) {
a.state = 'FALLING';
a.vy = 3.5;
a.vx = (Math.random() - 0.5) * 3;
a.timer = 0;
a.r = R_FALL;
}
if (b.state === 'STANDING' && (a.state === 'FALLING' || a.state === 'DOWN')) {
b.state = 'FALLING';
b.vy = 3.5;
b.vx = (Math.random() - 0.5) * 3;
b.timer = 0;
b.r = R_FALL;
}
// Falling into down = come to rest
if (a.state === 'FALLING' && b.state === 'DOWN') {
a.state = 'DOWN';
a.vx = 0; a.vy = 0;
a.timer = 0;
a.r = R_DOWN;
}
if (b.state === 'FALLING' && a.state === 'DOWN') {
b.state = 'DOWN';
b.vx = 0; b.vy = 0;
b.timer = 0;
b.r = R_DOWN;
}
}
}
}
}
function draw() {
ctx.clearRect(0, 0, canvas.width, canvas.height);
// Background rails
ctx.strokeStyle = '#2a2a30';
ctx.lineWidth = 4;
ctx.beginPath();
ctx.moveTo(230, 80);
ctx.lineTo(230, 560);
ctx.moveTo(570, 80);
ctx.lineTo(570, 560);
ctx.stroke();
// Steps
ctx.fillStyle = '#3a3a42';
for (const s of steps) {
ctx.fillRect(235, s.y - 4, 330, 8);
// Step edge highlight
ctx.fillStyle = '#4a4a52';
ctx.fillRect(235, s.y - 4, 330, 2);
ctx.fillStyle = '#3a3a42';
}
// People
for (const p of people) {
ctx.save();
ctx.translate(p.x, p.y);
ctx.strokeStyle = '#e8e8e8';
ctx.lineWidth = 2.2;
ctx.lineCap = 'round';
ctx.lineJoin = 'round';
if (p.state === 'STANDING' || p.state === 'RECOVERING') {
const h = (p.state === 'RECOVERING') ? 10 : 18;
// Head
ctx.beginPath();
ctx.arc(0, -h, 6, 0, Math.PI * 2);
ctx.stroke();
// Body
ctx.beginPath();
ctx.moveTo(0, -h + 6);
ctx.lineTo(0, 6);
ctx.stroke();
// Arms
ctx.beginPath();
ctx.moveTo(0, -h + 10);
ctx.lineTo(-9, -h + 16);
ctx.moveTo(0, -h + 10);
ctx.lineTo(9, -h + 16);
ctx.stroke();
// Legs
ctx.beginPath();
ctx.moveTo(0, 6);
ctx.lineTo(-7, 20);
ctx.moveTo(0, 6);
ctx.lineTo(7, 20);
ctx.stroke();
} else if (p.state === 'FALLING') {
// Tilted / tumbling pose
ctx.beginPath();
ctx.arc(-4, -10, 6, 0, Math.PI * 2);
ctx.stroke();
ctx.beginPath();
ctx.moveTo(-4, -4);
ctx.lineTo(6, 10);
ctx.stroke();
ctx.beginPath();
ctx.moveTo(-4, 0);
ctx.lineTo(-12, 6);
ctx.moveTo(-4, 0);
ctx.lineTo(4, 8);
ctx.stroke();
ctx.beginPath();
ctx.moveTo(6, 10);
ctx.lineTo(-2, 22);
ctx.moveTo(6, 10);
ctx.lineTo(10, 20);
ctx.stroke();
} else if (p.state === 'DOWN') {
// Horizontal / lying down
ctx.beginPath();
ctx.arc(-14, 0, 6, 0, Math.PI * 2);
ctx.stroke();
ctx.beginPath();
ctx.moveTo(-8, 0);
ctx.lineTo(8, 0);
ctx.stroke();
ctx.beginPath();
ctx.moveTo(-8, -2);
ctx.lineTo(-14, -8);
ctx.moveTo(-8, -2);
ctx.lineTo(-4, -10);
ctx.stroke();
ctx.beginPath();
ctx.moveTo(8, 0);
ctx.lineTo(14, 6);
ctx.moveTo(8, 0);
ctx.lineTo(12, 8);
ctx.stroke();
}
ctx.restore();
}
// Direction indicator
ctx.fillStyle = reversed ? '#5c5' : '#c55';
ctx.font = 'bold 14px system-ui';
ctx.textAlign = 'center';
ctx.fillText(reversed ? 'REVERSED ↓ FAST' : 'NORMAL ↑', 400, 50);
}
function loop() {
updateSteps();
updatePhysics();
draw();
requestAnimationFrame(loop);
}
btn.addEventListener('click', () => {
reversed = !reversed;
if (reversed) {
vEsc = { x: 0, y: 7.5 }; // high speed downward
btn.textContent = 'Restore Normal';
btn.classList.add('reversed');
status.textContent = 'State: REVERSED (down fast)';
} else {
vEsc = { x: 0, y: -1.6 };
btn.textContent = 'Reverse Escalator';
btn.classList.remove('reversed');
status.textContent = 'State: Normal (up)';
}
});
loop();
</script>
</body>
</html>
What it actually does
When you press the button, the escalator velocity instantly jumps from a slow upward drift to a fast downward pull. Every standing figure detects the velocity gap, loses balance, and enters the falling state with downward momentum. They slide downward, colliding with figures below them; any collision with a falling or down figure knocks the other into falling as well. Once a figure has fallen long enough (or hits the bottom), it becomes down—drawn horizontally with a larger radius—blocking anyone sliding into it. Those blocked figures either come to rest on the pile or tumble over it. After a shared timer expires and there is open space around them, down figures transition through recovering and back to standing, slowly matching the escalator velocity again.
Special-cased elements: the initial placement of the 18 figures on steps, the button toggle that flips vEsc, and the timer-based transition from down to recovering (though the timer is identical for every figure and recovery is gated by a clear-space check). The physics is hand-written with no library.
What it does badly: the vertical-only escalator means the pile tends to accumulate near the bottom rather than spreading across a slope; stick figures have no articulated joints, so rotation is approximate; collision resolution is simple positional pushing without rotational inertia, so bodies can overlap slightly before separation; and recovery requires explicit empty space, which sometimes leaves figures stuck in a dense pile longer than a real human might. The result is chaotic and emergent, but not physically precise.
Attachments
thinkingmachines/inkling — page