Run Detail
completedernie-5.5-flash-preview:freeRecorded 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
242.7s
Total Tokens
51,458
Input Tokens
433
Output Tokens
51,025
Reasoning Tokens
45,789
Reasoning Effort
high
Est. Cost
$0.0000
Started
11/11/2026, 3:01:06 PM
OR Provider
Baidu
Finish Reason
stop
Generation ID
gen-1794409267-mTncWwgLMCX1IaLLVCdE
Turns (1)
Turn #1
433 in51,025 out45,789 reasoning51,458 total242.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
A person is a single point mass (the centre of mass) carrying a scalar lean angle and its rate, a state flag (up / down / rising), and a handful of per‑body constants (height, mass, grip, a balance stiffness, and a cap on how hard they can correct). While up with footing they behave like an inverted pendulum: gravity amplifies any lean, the body pushes back toward vertical up to a fixed maximum torque, and the horizontal acceleration of the step under their feet injects a toppling torque — the feet get yanked, the mass lags. Balance is lost when lean passes a fall threshold: the restoring torque saturates and can no longer catch it, so the body drops to a lying pose and becomes a low obstacle. Two figures in the same place are resolved as circles — pushed apart with an inelastic impulse — and when a standing figure runs into a downed one the impact is fed into the standing figure's lean as a trip, so a body on the ground genuinely brings down whoever arrives behind it. Getting up is the same rule read backwards: a downed figure rises only after it has been still a moment, the belt isn't accelerating violently, and nothing is on top of it.
The page
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="utf-8">
<meta name="viewport" content="width=device-width,initial-scale=1">
<title>Escalator</title>
<style>
*{box-sizing:border-box}
html,body{margin:0;height:100%;background:#0e1116;overflow:hidden;
font-family:-apple-system,Segoe UI,Roboto,Helvetica,Arial,sans-serif;color:#c7d0db}
#c{display:block;position:fixed;inset:0}
#ui{position:fixed;left:16px;top:14px;display:flex;flex-direction:column;gap:9px;
align-items:flex-start;user-select:none}
button{font:600 15px/1 inherit;padding:11px 17px;border-radius:11px;border:1px solid #3a4657;
background:#1b2230;color:#e7edf4;cursor:pointer;transition:background .12s,transform .05s}
button:hover{background:#243ă}
button:hover{background:#232c3c}
button:active{transform:translateY(1px)}
button.on{background:#5a2230;border-color:#8a3a4a}
#hud{font-size:13px;opacity:.82;letter-spacing:.02em}
b{color:#eef3f8}
</style>
</head>
<body>
<canvas id="c"></canvas>
<div id="ui">
<button id="rev">Reverse escalator</button>
<div id="hud"></div>
</div>
<script>
"use strict";
const cv=document.getElementById('c'), ctx=cv.getContext('2d');
const btn=document.getElementById('rev'), hud=document.getElementById('hud');
/* ---------- world (fixed coords, letterboxed) ---------- */
const W0=960,H0=600;
let scale=1,offX=0,offY=0,DPR=1;
/* escalator geometry: incline from bottom-left up to top-right */
const bx=130, tx=830, groundY=515, ty=150;
const tanT=(groundY-ty)/(tx-bx);
const theta=Math.atan2(groundY-ty,tx-bx);
const cosT=Math.cos(theta), sinT=Math.sin(theta);
const L=Math.hypot(tx-bx,groundY-ty);
function surface(x){ if(x<=bx)return groundY; if(x>=tx)return ty; return groundY-(x-bx)*tanT; }
/* ---------- belt ---------- */
const normalSpeed=26, reverseSpeed=320, A_BELT=3400; // A_BELT = max belt accel
let beltTarget=normalSpeed, beltV=normalSpeed, beltPhase=0, abx=0, reversed=false;
/* ---------- physics constants ---------- */
const GRAV=1500, TOPPLE_G=300, RESTORE_DAMP=3.0, ACCEL_GAIN=0.28;
const FALL_ANGLE=0.55, FALL_SHOVE=45, BOUNCE=0.18, GROUND_FRICTION=4;
const REST=0.12, RISE_TIME=1.1, IDLE_SWAY=0.15;
/* ---------- helpers ---------- */
const rnd=(a,b)=>a+Math.random()*(b-a);
const clamp=(v,a,b)=>v<a?a:v>b?b:v;
const lerp=(a,b,t)=>a+(b-a)*t;
const ease=t=>t*t*(3-2*t);
function comHeight(p){
if(p.state==='down') return p.R*0.9;
if(p.state==='rising')return lerp(p.R*0.9,p.h*0.55,ease(p.riseT));
return p.h*0.55;
}
/* ---------- people ---------- */
let people=[], now=0;
function makePerson(s){
const h=rnd(36,50);
const p={ x:bx+s*cosT, y:0, vx:0, vy:0, h, R:h*0.27, m:h,
lean:rnd(-0.04,0.04), leanVel:0, leanKick:0, state:'up', grounded:true,
grip:rnd(6,10), slideGrip:rnd(1.5,3), stability:rnd(1.35,2.1),
maxRestore:rnd(6,11), downTimer:0, riseT:0, riseFrom:0, phase:rnd(0,6.28),
hue:rnd(0,360) };
p.y=surface(p.x)-comHeight(p); p.vx=beltV*cosT;
return p;
}
function init(){
people=[]; const N=18;
for(let i=0;i<N;i++){
const s=70+(L-140)*(i/(N-1))+rnd(-8,8);
people.push(makePerson(clamp(s,40,L-40)));
}
}
function respawn(p){ // recycle: reappear at the foot of the escalator
const s=rnd(6,26);
p.x=bx+s*cosT; p.y=surface(p.x)-comHeight(p);
p.vx=beltV*cosT; p.vy=0; p.lean=rnd(-0.04,0.04); p.leanVel=0; p.leanKick=0;
p.state='up'; p.grounded=true; p.downTimer=0; p.riseT=0;
}
/* ---------- belt update ---------- */
function updateBelt(dt){
const prev=beltV, dv=beltTarget-beltV, md=A_BELT*dt;
beltV+=clamp(dv,-md,md);
abx=((beltV-prev)/dt)*cosT; // horizontal component of belt accel
beltPhase+=beltV*dt;
}
/* ---------- per-person update ---------- */
function updatePerson(p,dt){
const onBelt=(p.x>bx&&p.x<tx);
const beltVx=onBelt?beltV*cosT:0;
const beltAx=onBelt?abx:0;
if(p.state==='up'){
const aGrav=(TOPPLE_G/p.h)*Math.sin(p.lean); // inverted pendulum
const aAccel=-(beltAx/p.h)*Math.cos(p.lean)*ACCEL_GAIN; // feet yanked, mass lags
let restore=0;
if(p.grounded){
restore=-(p.stability*TOPPLE_G/p.h)*p.lean - RESTORE_DAMP*p.leanVel;
restore=clamp(restore,-p.maxRestore,p.maxRestore); // saturating control
}
const idle=p.grounded?Math.sin(now*1.3+p.phase)*IDLE_SWAY:0;
const kick=p.leanKick; p.leanKick=0;
p.leanVel+=(aGrav+aAccel+restore+idle+kick)*dt;
p.lean += p.leanVel*dt;
if(Math.abs(p.lean)>FALL_ANGLE){ // LOST BALANCE
const dir=Math.sign(p.lean)||1;
p.state='down'; p.downTimer=0; p.lean=dir*1.5; p.leanVel=0;
p.vx+=dir*FALL_SHOVE; p.vy+=30;
}
} else if(p.state==='rising'){
p.riseT+=dt/RISE_TIME;
p.lean=lerp(p.riseFrom,0,ease(Math.min(1,p.riseT)));
if(Math.abs(p.leanKick)>2.5){ p.state='down'; p.downTimer=0; p.lean=(Math.sign(p.leanKick)||1)*1.5; }
p.leanKick=0;
if(p.riseT>=1){ p.state='up'; p.lean=0; p.leanVel=0; p.riseT=0; }
} else { // down
p.downTimer+=dt; p.leanKick=0;
if(canGetUp(p)){ p.state='rising'; p.riseT=0; p.riseFrom=p.lean; p.leanVel=0; }
}
/* carry / walk */
if(p.grounded){
if(onBelt){
const g=(p.state==='down')?p.slideGrip:p.grip;
p.vx+=(beltVx-p.vx)*Math.min(1,g*dt);
} else {
p.vx*=(1-Math.min(1,GROUND_FRICTION*dt));
if(p.state==='up'){
if(p.x>=tx && p.vx<45) p.vx=45; // walk off the top
else if(p.x<bx && beltTarget>0 && p.vx<45) p.vx=45; // walk on at the bottom
}
}
}
/* integrate */
p.vy+=GRAV*dt; p.x+=p.vx*dt; p.y+=p.vy*dt;
/* recycle only while running the normal (up) direction */
if(beltTarget>0 && p.state==='up' && p.x>W0-30) respawn(p);
}
function canGetUp(p){
if(p.downTimer<0.8) return false;
if(Math.abs(abx)>500) return false; // not during a violent jerk
if(!p.grounded) return false; // needs footing
for(const q of people){
if(q===p) continue;
const dx=q.x-p.x, dy=q.y-p.y, md=(p.R+q.R)*0.75;
if(dx*dx+dy*dy<md*md && p.downTimer<5) return false; // needs room (5s failsafe)
}
return true;
}
/* ---------- collisions ---------- */
function collide(a,b){
let dx=b.x-a.x, dy=b.y-a.y, d2=dx*dx+dy*dy; const md=a.R+b.R;
if(d2>=md*md) return;
if(d2<1e-6){ dx=0.1; dy=0; d2=0.01; }
const d=Math.sqrt(d2), nx=dx/d, ny=dy/d, ov=md-d;
const ia=1/a.m, ib=1/b.m, is=ia+ib;
a.x-=nx*ov*(ia/is); a.y-=ny*ov*(ia/is);
b.x+=nx*ov*(ib/is); b.y+=ny*ov*(ib/is);
const avx=a.vx, bvx=b.vx;
const rvx=b.vx-a.vx, rvy=b.vy-a.vy, vn=rvx*nx+rvy*ny;
if(vn<0){
const imp=-(1+REST)*vn/is;
a.vx-=imp*nx*ia; a.vy-=imp*ny*ia; b.vx+=imp*nx*ib; b.vy+=imp*ny*ib;
trip(a,b, avx-bvx, -vn); // a runs into b
trip(b,a, bvx-avx, -vn); // b runs into a
}
if(a.state==='up'&&b.state==='up'){ const j=clamp((a.vx-b.vx)*0.015,-1.2,1.2); a.leanKick-=j; b.leanKick+=j; }
}
function trip(a,b,rel,appr){
if(b.state!=='down') return; // only a downed body trips you
if(a.state==='rising'){ if(appr>70){ a.state='down'; a.downTimer=0; a.lean=(Math.sign(rel)||1)*1.5; a.leanVel=0; } return; }
if(a.state!=='up') return;
const dir=Math.sign(rel)||1, sev=clamp(appr/120,0,2.2);
a.leanVel+=dir*sev*1.5; a.leanKick+=dir*sev*2.0;
}
/* ---------- constraints ---------- */
function constrain(p){
if(p.x<14){ p.x=14; if(p.vx<0)p.vx*=-0.25; }
if(p.x>W0-14){ p.x=W0-14; if(p.vx>0)p.vx*=-0.25; }
const rest=surface(p.x)-comHeight(p);
if(p.y>rest){ p.y=rest; if(p.vy>0)p.vy=(p.vy>80)?-p.vy*BOUNCE:0; p.grounded=true; }
else p.grounded=false;
p.vx=clamp(p.vx,-700,700); p.vy=clamp(p.vy,-1000,1000); p.leanVel=clamp(p.leanVel,-12,12);
}
/* ---------- drawing ---------- */
function line(x1,y1,x2,y2){ ctx.beginPath(); ctx.moveTo(x1,y1); ctx.lineTo(x2,y2); ctx.stroke(); }
function drawEscalator(){
ctx.lineCap='round';
ctx.strokeStyle='#232c39'; ctx.lineWidth=34; line(bx,groundY,tx,ty);
ctx.strokeStyle='#2f3a4b'; ctx.lineWidth=24; line(bx,groundY,tx,ty);
const gap=30; let s0=((beltPhase%gap)+gap)%gap;
for(let s=s0;s<L;s+=gap){
const x=bx+s*cosT, y=groundY-s*sinT;
ctx.strokeStyle='#7f8da0'; ctx.lineWidth=4; line(x-13,y,x+13,y);
ctx.strokeStyle='#556476'; ctx.lineWidth=3; line(x-13,y,x-13,y+9);
}
const hr=30;
ctx.strokeStyle='#161b22'; ctx.lineWidth=9; line(bx,groundY-hr,tx,ty-hr);
ctx.strokeStyle='#aeb8c4'; ctx.lineWidth=2; ctx.setLineDash([9,15]); ctx.lineDashOffset=-beltPhase;
line(bx,groundY-hr,tx,ty-hr); ctx.setLineDash([]);
ctx.fillStyle='#232c39';
ctx.fillRect(-40,groundY,bx+42,26);
ctx.fillRect(tx-2,ty,W0-tx+42,26);
ctx.fillStyle='#3a4657';
ctx.fillRect(-40,groundY,bx+42,4);
ctx.fillRect(tx-2,ty,W0-tx+42,4);
}
function drawPerson(p){
const ax=Math.sin(p.lean), ay=-Math.cos(p.lean); // body up-axis
const px=-ay, py=ax; // perpendicular
const hipX=p.x, hipY=p.y;
const shD=0.28*p.h, hdD=0.46*p.h, ftD=0.55*p.h;
const shX=hipX+ax*shD, shY=hipY+ay*shD;
const hdX=hipX+ax*hdD, hdY=hipY+ay*hdD;
const ftX=hipX-ax*ftD, ftY=hipY-ay*ftD;
const down=(p.state==='down')?1:(p.state==='rising'?(1-p.riseT):0);
const sp=0.10*p.h*(1+down*1.6);
const col='hsl('+(p.hue|0)+',55%,'+(60-down*10)+'%)';
ctx.strokeStyle=col; ctx.fillStyle=col; ctx.lineWidth=3; ctx.lineCap='round';
line(hipX,hipY, ftX+px*sp, ftY+py*sp);
line(hipX,hipY, ftX-px*sp, ftY-py*sp);
line(hipX,hipY, shX, shY);
const sw=0.25+down*0.9, aSw=Math.sin(now*4+p.phase)*0.15*(1-down);
line(shX,shY, shX+px*sp*1.4+ax*shD*sw*(1+aSw), shY+py*sp*1.4+ay*shD*sw*(1+aSw));
line(shX,shY, shX-px*sp*1.4-ax*shD*sw*(1-aSw), shY-py*sp*1.4-ay*shD*sw*(1-aSw));
ctx.beginPath(); ctx.arc(hdX,hdY,0.11*p.h,0,6.283); ctx.fill();
}
/* ---------- render ---------- */
let hudTick=0;
function render(){
const w=window.innerWidth, h=window.innerHeight;
ctx.setTransform(DPR,0,0,DPR,0,0);
ctx.fillStyle='#0e1116'; ctx.fillRect(0,0,w,h);
ctx.save(); ctx.translate(offX,offY); ctx.scale(scale,scale);
drawEscalator();
for(const p of people) drawPerson(p);
ctx.restore();
if((hudTick++ & 7)===0){
let down=0; for(const p of people) if(p.state==='down') down++;
hud.innerHTML='Direction: <b>'+(reversed?'DOWN':'UP')+'</b> · belt <b>'+Math.abs(beltV).toFixed(0)+
'</b> · <b>'+people.length+'</b> aboard · <b>'+down+'</b> down';
}
}
/* ---------- main loop ---------- */
let last=0;
function frame(t){
if(!last) last=t;
let dt=(t-last)/1000; last=t; now=t/1000;
dt=Math.min(dt,1/30);
updateBelt(dt);
for(const p of people) updatePerson(p,dt);
for(let it=0;it<3;it++)
for(let i=0;i<people.length;i++)
for(let j=i+1;j<people.length;j++) collide(people[i],people[j]);
for(const p of people) constrain(p);
render();
requestAnimationFrame(frame);
}
/* ---------- setup ---------- */
function resize(){
DPR=Math.min(window.devicePixelRatio||1,2);
const w=window.innerWidth, h=window.innerHeight;
cv.width=Math.round(w*DPR); cv.height=Math.round(h*DPR);
cv.style.width=w+'px'; cv.style.height=h+'px';
scale=Math.min(w/W0,h/H0); offX=(w-W0*scale)/2; offY=(h-H0*scale)/2;
}
window.addEventListener('resize',resize);
btn.addEventListener('click',()=>{
reversed=!reversed;
beltTarget=reversed?-reverseSpeed:normalSpeed;
btn.textContent=reversed?'Return to normal':'Reverse escalator';
btn.classList.toggle('on',reversed);
});
resize(); init(); requestAnimationFrame(frame);
</script>
</body>
</html>
What it actually does
You load into a calm scene: 18 stick figures spaced along an up‑running incline, swaying faintly, steps and handrail creeping upward. Press Reverse and the belt ramps from +26 to −320 in about a tenth of a second. That ramp is the whole disaster: the horizontal acceleration of the steps (~3000 px/s²) is fed into each figure's inverted‑pendulum lean. Because the restoring torque is capped, anyone whose lean is pushed past ~0.55 rad can't recover — gravity finishes the topple. Shorter and lower‑stability figures go first; the tallest and steadiest sometimes ride the initial jerk out, then get carried down at speed and are taken out when they hit the heap at the bottom. Fallen bodies are real circle‑obstacles: a standing figure that runs into one at speed gets an angular trip impulse and usually goes down too, so the pile propagates on its own. Figures that end up with a still moment, footing, and headroom push back up over ~1.1 s; in a dense scrum they mostly can't, so it churns. Press again and the belt ramps back up with an equal‑and‑opposite jerk that tosses the pile the other way, after which people sort themselves out and ride up.
Things I nudged or special‑cased, honestly:
- Recycling. To keep the escalator populated indefinitely, a figure that walks off the top is teleported to the foot and re‑boarded. That's a visible pop at the ends, and the "walk off the top / walk on at the bottom" nudge (a fixed 45 px/s drift) is scripted behaviour, not emergent.
- Getting up uses a room‑and‑footing test with a 5‑second failsafe that lets a long‑pinned figure force itself up through a crowd. Without the failsafe a dense pile would lock forever; with it, "needs room" is only mostly true.
- Idle sway is a small decorative torque so riders aren't frozen.
- The lean is a separate scalar from the centre of mass — the body tilts visually but the point mass doesn't actually swing sideways as it leans, so a topple is really "lean crosses threshold → snap to lying → CoM drops under gravity." It reads fine but it isn't a true rigid‑body fall.
What it does badly / where to poke it:
- Tuning is guesswork without running it. The fall fraction on the first reversal is set by
ACCEL_GAIN,reverseSpeed,A_BELT,FALL_ANGLEand the stability spread. My estimate is "most fall, a couple of the tallest survive the first jerk," but it could come out as everyone instantly (looks synchronized) or nobody (belt too gentle). Those are the first knobs to turn. - The pile is a dense shoving scrum, not a tall heap. Vertical stacking is only whatever the circle collisions happen to hold up; gravity and the floor constraint keep pulling people back down, so expect overlap and jitter in the bottom‑left corner rather than a neat mound.
- Frame‑rate sensitivity. The tuning assumes ~60 fps; on a slow frame the acceleration spike is integrated coarser and results will differ.
- Downed figures never re‑board on their own unless they get up and drift right during a normal‑direction phase — during continuous reverse the bottom just packs and stays packed, which is correct but means "recovery" only really shows when you press the button back.
Attachments
baidu/ernie-5.5-flash-preview:free — page