Run Detail
completedglm-5.3-flashRecorded 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
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
30:00Did Elon Musk's team "train the gay away"... and make Grok 4.7 worse?
Sep 26, 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
16:54Stealth Union Alpha: Is this another cheap GPT model? (better than Luna, cheaper than Terra?)
Sep 16, 2026 · YouTube
16:45DeepSeek V4.1 Flash Is Shockingly Good for the Price
Sep 10, 2026 · YouTube
17:14How much better is GPT-6 Astra over Claude Opus 5? Real Website and Coding Tests
Sep 5, 2026 · YouTube
29:13Implementing a multiplayer game with GPT-6 Astra (+ Gemini 3.8, Opus 5, Sol Pro)
Sep 5, 2026 · YouTube
17:31Testing Gemini 3.8 Flash on Real Coding Challenges (vs. other models)
Sep 2, 2026 · YouTube
17:37Tencent Hy4 Preview Tested: Is It Really Better Than Kimi K3 and GLM 5.3?
Aug 28, 2026 · YouTube
23:58Qwen 3.8 Flash Tested: UI, Coding, Physics & more - compared to Opus 5, Sol Pro, Grok
Aug 27, 2026 · YouTube
14:50Stealth Ox Alpha: a new GLM model! Full test (coding & writing) against Grok, Gemini, GPT & others
Aug 21, 2026 · YouTube
21:54GLM 5.3 Tested: Does it beat Claude Opus 5 & Grok 4.6?
Aug 19, 2026 · YouTube
21:23Giving Qwen 3.8 27B another chance (+ GLM 5.2). Testing against GPT, Gemini, Grok etc.
Aug 18, 2026 · YouTube
51:00AI Coding Showdown: Grok 4.6, Gemini 3.7, Terra-Pro, Qwen3.8 2.4TB, Muse Glimmer & more
Aug 15, 2026 · YouTube
27:51Testing Gemini 3.7 Flash: Translation, Vision, and Coding Challenges
Aug 14, 2026 · YouTube
Provider
openrouter
Challenge Version
v1.0
Turns
1
Duration
627.3s
Total Tokens
106,366
Input Tokens
743
Output Tokens
105,623
Reasoning Tokens
97,841
Reasoning Effort
default
Est. Cost
$0.0529
Started
11/10/2026, 4:02:44 PM
OR Provider
Together
Finish Reason
stop
Generation ID
gen-1794326563-bUft8ryoLtEBNJONkc0b
Turns (1)
Turn #1
743 in105,623 out97,841 reasoning106,366 total627.2s
user
You build physics demonstrations for a science museum. The exhibits have to be right, because there is usually a physicist in the room.
Build me the falling slinky.
The exhibit
A single HTML page. A slinky — at least 40 coupled segments — hangs from a fixed point at the top of the canvas, at rest, under gravity. Then it is released.
Controls:
- Release — lets go of the top. Reset — hangs it back up, at rest.
- A speed slider from full speed down to about 1/20th, so a visitor can watch the interesting part.
- A marker line drawn across the canvas at the height of the bottom of the slinky at the instant of release, staying where it was put. Visitors need something to compare against.
- A running clock in milliseconds since release.
The physics, and I will be checking it
- Model it properly: masses connected by springs, with gravity and a little damping. Hooke's law between neighbours, integrated over small time steps.
- The hanging state must be the true equilibrium. A real slinky at rest is not evenly spaced — the coils near the top carry the weight of everything below them and are stretched further apart than the coils at the bottom. Your initial condition must have this. Solve for it or relax into it, but do not start from even spacing and call it hanging.
- The integrator must be stable at the stiffness you choose. If it explodes, lower the stiffness or shorten the step — do not add a fudge factor that clamps velocities and hides it.
- No scripted behaviour. Every segment obeys the same rules. Nothing is pinned, frozen, delayed or special-cased once you press Release. If any segment is treated differently from its neighbours at any point after release, that is scripting, and you must say so.
House rules
- One file. Everything inline — no CDN, no external stylesheet, font, script or image.
data:URIs are fine. - No libraries. No physics engine.
- 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 prediction
Before the file, and before you write it. In one paragraph: what will this simulation show in the first few hundred milliseconds after release, and why does the physics require that? Be concrete about what each end of the slinky does and roughly when.
Commit to this. It is the claim I am going to test your simulation against.
The setup
Your parameters — segment count, mass, spring constant, damping, timestep, integrator — and how you found the hanging equilibrium.
The file
The single fenced html block.
What it actually shows
Now be honest. Having written it, does the simulation reproduce what you predicted?
Say plainly if it does not. Say if you are unsure. Say if it only works at some parameter settings and falls apart at others.
Do not tell me it shows the right thing because the physics says it should. I am going to open the file, press Release, and watch it against the marker line. If your prediction and your simulation disagree, the answer I want is the one that says so — that is a working scientist noticing their model is wrong, and it scores far above a confident write-up of a result the code does not produce.
assistant
The prediction
Press Release, and in the first few hundred milliseconds this happens, in a fixed order. The top end drops immediately, and much harder than gravity: the topmost mass was carrying the tension of the whole chain below it — segment 48 is stretched 33.6 mm and pulls down with 2.35 N, forty-eight times that mass's weight — so the instant it is free its acceleration is ≈ 49g ≈ 480 m/s². Within ~10 ms and about 2 cm of fall it is moving at ≈ 4 m/s, and the top coils collapse into a bunched cap. That cap descends at roughly constant speed ≈ √(2gL) ≈ 4.0 m/s — it does not accelerate like free fall — while the collapse front walks down the hanging profile at the chain's wave speed √(k/m) ≈ 118 coils/s, physically decelerating as it approaches the bottom (the coils there are nearly unstretched), so the collapse settles onto the bottom end rather than slamming it. By t ≈ 0.2 s the front is half-way down and the cap has swept past the equilibrium positions of the middle coils. The bottom end, meanwhile, does nothing at all. Its weight is exactly balanced by the tension of segment 1, and no influence travels faster than the wave speed, so that tension cannot change until the front arrives. I commit to this as the headline: the bottom-end readout holds at exactly 0.0 mm — the coil sits motionless on the red marker line — until t* = N√(m/k) = √(2L/g) ≈ 0.41 s, while the centre-of-mass row reads a clean 9.80 m/s² from the first instant and the COM has dropped ~20 cm by t = 0.2 s. One disclosure baked into the prediction: this model has no coil-contact force, so from ~0.25 s the bunched coils stream down past the still-holding lower coils and below the marker line — a real slinky's coils would pile up on top of the bottom end instead. The bottom end's stillness is unaffected. At t* ≈ 0.41 s the front reaches the last coil, the bottom leaves the marker, and the whole thing free-falls out of view by ~0.6 s.
The setup
- Chain: 49 equal masses, m = 5 g each (245 g total — slinky-like), 48 spring segments, rest length 0 (the ideal-slinky limit; this is what makes the bottom coils bunch), k = 70 N/m per segment, chosen so the hanging length L = Σⱼ j·m·g/k = m·g·N(N+1)/2k ≈ 0.823 m fills the plate. Motion is vertical (1D). g = 9.8 m/s².
- Damping: a light dashpot, c = 12 mN·s/m, in parallel with every spring, acting on relative velocity — purely internal, so momentum is conserved and the COM falls at exactly g. c/k = 0.17 ms, far below every bulk timescale; it exists only to calm the lattice-scale ringing behind the collapse front.
- Hanging equilibrium — solved, not relaxed: segment j supports the j masses below it, so its tension is j·m·g, its stretch j·m·g/k, and yⱼ = j(j+1)·m·g/2k with v = 0. The net force on every mass is then identically zero (I checked the residual algebraically; it vanishes up to floating-point noise). Top gaps ≈ 34 mm, bottom gaps ≈ 0.7 mm — the true non-uniform hang.
- Integrator: symplectic (semi-implicit) Euler, fixed Δt = 0.25 ms. Fastest normal mode 2√(k/m) ≈ 237 rad/s; explicit stability requires Δt < 2/ω_max ≈ 8.4 ms, so ω_max·Δt ≈ 0.06 — a 33× margin. No velocity clamps, no fudge factors anywhere. The speed slider rescales simulated time per frame, never Δt, so playback rate cannot touch stability or the physics.
- Scripting disclosure: before Release the mount holds the top mass — that is the physical fixture, and since the state is the exact equilibrium nothing moves regardless. At Release the mount is removed and from that instant every mass integrates the identical law: no pins, freezes, delays or special cases. The readouts (bottom displacement, lowest moving coil, COM acceleration by second difference) are measured from the state, not from a schedule.
The file
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="utf-8">
<meta name="viewport" content="width=device-width, initial-scale=1">
<title>The Falling Slinky</title>
<style>
:root{
--paper:#f3efe6;
--ink:#26221b;
--ink60:rgba(38,34,27,.62);
--ink40:rgba(38,34,27,.4);
--hair:rgba(38,34,27,.26);
--hair2:rgba(38,34,27,.13);
--verm:#c13a1b;
--verm-d:#9c2d12;
--mono:ui-monospace,"SF Mono","Cascadia Mono",Menlo,Consolas,"Liberation Mono",monospace;
--serif:Georgia,"Iowan Old Style","Palatino Linotype","Times New Roman",serif;
}
*{box-sizing:border-box;margin:0;padding:0}
html,body{height:100%}
body{background:var(--paper);color:var(--ink);font-family:var(--serif);display:flex;flex-direction:column;min-height:100vh;-webkit-font-smoothing:antialiased}
header{display:flex;align-items:flex-end;justify-content:space-between;gap:16px;padding:16px 24px 13px;border-bottom:1px solid var(--hair)}
.over{font-family:var(--mono);font-size:10px;letter-spacing:.24em;color:var(--verm)}
h1{font-size:clamp(22px,3vw,32px);font-weight:700;letter-spacing:-.015em;line-height:1.05;margin-top:5px}
.sub{font-style:italic;font-size:13.5px;color:var(--ink60);margin-top:4px}
.hdr-note{font-family:var(--mono);font-size:10px;letter-spacing:.14em;color:var(--ink60);text-align:right;line-height:1.8;white-space:nowrap}
main{flex:1;display:flex;min-height:0}
.stage{flex:1;position:relative;min-width:0;border-right:1px solid var(--hair)}
.stage canvas{position:absolute;inset:0;width:100%;height:100%;display:block}
.rail{width:346px;flex:none;overflow-y:auto}
.sec{padding:15px 20px 16px;border-bottom:1px solid var(--hair2)}
.lbl{font-family:var(--mono);font-size:9.5px;letter-spacing:.2em;text-transform:uppercase;color:var(--ink60);margin-bottom:9px}
.clock{font-family:var(--mono);font-variant-numeric:tabular-nums;font-size:30px;letter-spacing:.02em;white-space:nowrap}
.clock small{font-size:14px;color:var(--ink60)}
.clock.dim{color:var(--ink40);font-family:var(--serif);font-style:italic;font-size:21px}
.btns{display:flex;gap:9px}
button{font-family:var(--mono);font-size:11.5px;letter-spacing:.16em;text-transform:uppercase;padding:11px 0;flex:1;cursor:pointer;border-radius:2px}
#btnRel{background:var(--verm);color:var(--paper);border:1px solid var(--verm-d)}
#btnRel:hover:not(:disabled){background:var(--verm-d)}
#btnRel:disabled{background:transparent;color:var(--ink40);border:1px solid var(--hair);cursor:default}
#btnRst{background:transparent;color:var(--ink);border:1px solid var(--ink)}
#btnRst:hover{background:rgba(38,34,27,.07)}
.spdrow{display:flex;justify-content:space-between;align-items:baseline;margin:15px 0 2px}
.spdrow .lbl{margin:0}
.spdval{font-family:var(--mono);font-size:13px}
input[type=range]{-webkit-appearance:none;appearance:none;width:100%;height:24px;background:transparent;cursor:pointer}
input[type=range]::-webkit-slider-runnable-track{height:2px;background:var(--hair)}
input[type=range]::-webkit-slider-thumb{-webkit-appearance:none;width:13px;height:13px;border-radius:50%;background:var(--verm);margin-top:-5.5px;box-shadow:0 0 0 1.5px var(--paper),0 0 0 2.5px var(--verm-d)}
input[type=range]::-moz-range-track{height:2px;background:var(--hair)}
input[type=range]::-moz-range-thumb{width:11px;height:11px;border-radius:50%;background:var(--verm);border:none;box-shadow:0 0 0 1.5px var(--paper),0 0 0 2.5px var(--verm-d)}
.endticks{display:flex;justify-content:space-between;font-family:var(--mono);font-size:9.5px;letter-spacing:.08em;color:var(--ink60)}
.hint{font-size:12.5px;font-style:italic;color:var(--ink60);margin-top:10px;line-height:1.5}
.row{display:flex;justify-content:space-between;align-items:baseline;gap:10px;padding:8px 0;border-bottom:1px dashed var(--hair2)}
.row:last-child{border-bottom:none;padding-bottom:0}
.rl{font-size:10.5px;letter-spacing:.12em;text-transform:uppercase;color:var(--ink60)}
.rv{font-family:var(--mono);font-size:13.5px;font-variant-numeric:tabular-nums;white-space:nowrap}
.rv .u{color:var(--ink60);font-size:11px}
.lamp{font-family:var(--mono);font-size:10px;letter-spacing:.12em;text-transform:uppercase}
.lamp::before{content:"";display:inline-block;width:7px;height:7px;margin-right:6px;border:1px solid var(--ink40)}
.lamp.fall{color:var(--verm)}
.lamp.fall::before{background:var(--verm);border-color:var(--verm)}
.model p{font-family:var(--mono);font-size:10.5px;line-height:1.7;color:var(--ink60)}
.model b{color:var(--ink);font-weight:600}
footer{display:flex;justify-content:space-between;gap:14px;padding:9px 24px;border-top:1px solid var(--hair);font-family:var(--mono);font-size:9.5px;letter-spacing:.1em;text-transform:uppercase;color:var(--ink60)}
@media (max-width:900px){
main{flex-direction:column;flex:none}
.stage{flex:none;height:58vh;border-right:none;border-bottom:1px solid var(--hair)}
.rail{width:auto}
.hdr-note{display:none}
}
</style>
</head>
<body>
<header>
<div>
<div class="over">Exhibit 07 · A chain of 48 springs under gravity</div>
<h1>The Falling Slinky</h1>
<div class="sub">Released from its true hanging equilibrium — watch the bottom end refuse to move.</div>
</div>
<div class="hdr-note">49 masses · 48 Hooke segments<br>symplectic Euler · Δt = 0.25 ms</div>
</header>
<main>
<section class="stage" id="stage">
<canvas id="cv"></canvas>
</section>
<aside class="rail">
<div class="sec">
<div class="lbl">Clock · time since release</div>
<div class="clock dim" id="clock">holding</div>
</div>
<div class="sec">
<div class="lbl">Control</div>
<div class="btns">
<button id="btnRel" type="button">Release</button>
<button id="btnRst" type="button">Reset</button>
</div>
<div class="spdrow">
<span class="lbl">Playback speed</span>
<span class="spdval" id="spdVal">×1.00</span>
</div>
<input id="spd" type="range" min="0" max="1000" step="1" value="1000" aria-label="Playback speed">
<div class="endticks"><span>1/20×</span><span>1×</span></div>
<p class="hint">The whole event lasts about half a second at full speed. Try ×0.1: the bottom end sits on the red line for ≈ 400 ms while the top collapses onto it.</p>
</div>
<div class="sec">
<div class="lbl">Instruments · measured from the state</div>
<div class="row"><span class="rl">Bottom end</span><span class="rv"><span id="rBot">0.0</span> <span class="u">mm</span> <span class="lamp" id="rBotS">holding</span></span></div>
<div class="row"><span class="rl">Lowest moving coil</span><span class="rv" id="rFront">— / 48</span></div>
<div class="row"><span class="rl">Top end · drop</span><span class="rv"><span id="rTop">0.0</span> <span class="u">cm</span></span></div>
<div class="row"><span class="rl">Centre of mass · drop</span><span class="rv"><span id="rCom">0.0</span> <span class="u">cm</span></span></div>
<div class="row"><span class="rl">Centre of mass · accel</span><span class="rv"><span id="rComA">—</span> <span class="u">m/s²</span></span></div>
</div>
<div class="sec model">
<div class="lbl">Model · for the physicist in the room</div>
<p><b>49 masses</b> of 5 g joined by <b>48 Hooke segments</b>, k = 70 N/m, rest length 0, plus a light internal dashpot (c = 12 mN·s/m) acting on relative velocity; g = 9.8 m/s². The hanging state is <b>solved, not relaxed</b>: segment j carries the weight of the j masses below it, so its stretch is j·m·g/k — top gaps ≈ 34 mm, bottom gaps ≈ 0.7 mm, the true slinky bunching. Integration: <b>symplectic Euler, fixed Δt = 0.25 ms</b>; fastest mode 2√(k/m) ≈ 237 rad/s, explicit stability needs Δt < 8.4 ms — a 33× margin, and there are no clamps or fudge factors anywhere. The speed control rescales simulated time, never Δt. There is <b>no coil-contact force</b>, so bunched coils can pass through one another — a real slinky's cannot. Before Release the mount holds the top mass; at Release it is removed, and from that instant <b>every mass integrates the same law</b> — nothing is pinned, frozen, delayed or scripted. The readouts are computed from the state, not from a schedule.</p>
</div>
</aside>
</main>
<footer>
<span>The bottom end hangs because segment 1 carries exactly its weight — until the release wave arrives</span>
<span>one file · no libraries · no network</span>
</footer>
<script>
(function(){
'use strict';
/* ---------------- model ---------------- */
const N = 48, M = N + 1;
const mMass = 0.005; // kg per mass
const kSpring = 70; // N/m per segment
const cDamp = 0.012; // N·s/m dashpot per segment (internal, relative velocity)
const gGrav = 9.8; // m/s^2
const DT = 0.00025; // s, fixed substep (w_max*DT ~ 0.06, stability limit 2)
/* True hanging equilibrium, solved exactly:
segment j (joining masses j-1 and j) carries the weight of the j masses
below it -> tension j*m*g -> stretch j*m*g/k -> y_j = j(j+1)/2 * m*g/k.
Bottom mass at y = 0. Net force on every mass is exactly zero. */
const yEq = new Float64Array(M);
for (let j = 0; j < M; j++) yEq[j] = 0.5 * (mMass * gGrav / kSpring) * j * (j + 1);
let comEq = 0;
for (let j = 0; j < M; j++) comEq += yEq[j];
comEq /= M;
const y = new Float64Array(M), v = new Float64Array(M), aArr = new Float64Array(M);
let released = false, simT = 0, acc = 0;
/* COM history for the measured acceleration (second difference, 8 ms baseline) */
const CDEL = 32, CHN = 128;
const comBuf = new Float64Array(CHN);
let comHead = 0, comN = 0;
function resetSim(){
y.set(yEq); v.fill(0);
released = false; simT = 0; acc = 0; comN = 0; comHead = 0;
btnRel.disabled = false; btnRel.textContent = 'Release';
clockEl.classList.add('dim'); clockEl.textContent = 'holding'; clkN = null;
}
function release(){
if (released) return;
released = true; simT = 0; acc = 0; comN = 0; comHead = 0;
btnRel.disabled = true; btnRel.textContent = 'Released';
clockEl.classList.remove('dim');
clockEl.innerHTML = 'T+<span id="clkN">0000.0</span><small> ms</small>';
clkN = document.getElementById('clkN');
}
function substep(){
for (let i = 0; i < M; i++) aArr[i] = -gGrav; // gravity on every mass
for (let j = 1; j < M; j++){ // segment j: masses j-1 (low), j (high)
const f = (kSpring * (y[j] - y[j-1]) + cDamp * (v[j] - v[j-1])) / mMass;
aArr[j] -= f; // pulls the upper mass down
aArr[j-1] += f; // pulls the lower mass up
}
for (let i = 0; i < M; i++) v[i] += aArr[i] * DT; // symplectic Euler
for (let i = 0; i < M; i++) y[i] += v[i] * DT;
simT += DT;
let s = 0;
for (let i = 0; i < M; i++) s += y[i];
comBuf[comHead] = s / M;
comHead = (comHead + 1) % CHN;
if (comN < CHN) comN++;
}
function advance(dtSim){
acc += dtSim;
let n = 0;
while (acc >= DT && n < 4000){ substep(); acc -= DT; n++; }
if (n >= 4000) acc = 0; // drop backlog rather than spiral (unreachable at shipped settings)
}
function comAccel(){
if (comN < 2 * CDEL + 1) return NaN;
const i0 = (comHead - 1 + CHN) % CHN;
const i1 = (comHead - 1 - CDEL + CHN) % CHN;
const i2 = (comHead - 1 - 2 * CDEL + CHN) % CHN;
const h = CDEL * DT;
return (comBuf[i0] - 2 * comBuf[i1] + comBuf[i2]) / (h * h);
}
/* ---------------- dom ---------------- */
const $ = id => document.getElementById(id);
const btnRel = $('btnRel'), btnRst = $('btnRst'), clockEl = $('clock'),
spd = $('spd'), spdVal = $('spdVal'),
rBot = $('rBot'), rBotS = $('rBotS'), rFront = $('rFront'),
rTop = $('rTop'), rCom = $('rCom'), rComA = $('rComA');
let clkN = null;
let speed = 1;
function spdMap(){
speed = 0.05 * Math.pow(20, +spd.value / 1000); // 1/20x ... 1x
spdVal.textContent = speed > 0.995 ? '×1.00' : '×' + speed.toFixed(2);
}
spd.addEventListener('input', spdMap); spdMap();
btnRel.addEventListener('click', release);
btnRst.addEventListener('click', resetSim);
window.addEventListener('keydown', e => {
if (e.code === 'Space'){ e.preventDefault(); if (!released) release(); }
else if (e.code === 'KeyR') resetSim();
});
/* ---------------- canvas ---------------- */
const cv = $('cv'), ctx = cv.getContext('2d'), stage = $('stage');
let W = 100, H = 100, dpr = 1;
function resize(){
const r = stage.getBoundingClientRect();
dpr = window.devicePixelRatio || 1;
W = Math.max(60, r.width); H = Math.max(60, r.height);
cv.width = Math.round(W * dpr); cv.height = Math.round(H * dpr);
}
if (window.ResizeObserver) new ResizeObserver(resize).observe(stage);
window.addEventListener('resize', resize);
resize();
const YTOP = 0.95, YBOT = -0.75; // world window, metres, y up, marker at 0
const TAU = Math.PI * 2;
const INK = a => 'rgba(38,34,27,' + a + ')';
const VERM = '#c13a1b';
const MONO = 'ui-monospace,"SF Mono",Menlo,Consolas,monospace';
const SERIF = 'Georgia,serif';
let S = 1, cx = 0, R = 10, ry = 3;
const py = wy => (YTOP - wy) * S;
/* one full helical turn per segment; near half bright, far half faint */
function drawSlinky(yy, fa, ba, flw, blw){
const SUB = 16;
ctx.lineCap = 'round'; ctx.lineJoin = 'round';
ctx.beginPath();
for (let j = 1; j < M; j++){
const yl = py(yy[j-1]), yu = py(yy[j]);
for (let s = 0; s <= SUB; s++){
const ph = Math.PI + Math.PI * s / SUB;
const x = cx + R * Math.cos(ph);
const yc = yl + (yu - yl) * ph / TAU + ry * Math.sin(ph);
s === 0 ? ctx.moveTo(x, yc) : ctx.lineTo(x, yc);
}
}
ctx.strokeStyle = INK(ba); ctx.lineWidth = blw; ctx.stroke();
ctx.beginPath();
for (let j = 1; j < M; j++){
const yl = py(yy[j-1]), yu = py(yy[j]);
for (let s = 0; s <= SUB; s++){
const ph = Math.PI * s / SUB;
const x = cx + R * Math.cos(ph);
const yc = yl + (yu - yl) * ph / TAU + ry * Math.sin(ph);
s === 0 ? ctx.moveTo(x, yc) : ctx.lineTo(x, yc);
}
}
ctx.strokeStyle = INK(fa); ctx.lineWidth = flw; ctx.stroke();
}
function draw(){
ctx.setTransform(dpr, 0, 0, dpr, 0, 0);
ctx.clearRect(0, 0, W, H);
S = H / (YTOP - YBOT);
R = 0.042 * S; ry = 0.32 * R;
cx = Math.min(Math.max(W * 0.55, 120), Math.max(120, W - 90));
/* faint axis */
ctx.strokeStyle = INK(0.07); ctx.lineWidth = 1;
ctx.beginPath(); ctx.moveTo(cx, py(0)); ctx.lineTo(cx, py(yEq[N])); ctx.stroke();
/* ruler in centimetres, zero on the marker */
const rx = 44;
ctx.strokeStyle = INK(0.35); ctx.lineWidth = 1;
ctx.beginPath(); ctx.moveTo(rx + .5, 4); ctx.lineTo(rx + .5, H - 4); ctx.stroke();
ctx.font = '9px ' + MONO; ctx.fillStyle = INK(0.5);
ctx.textAlign = 'left'; ctx.textBaseline = 'middle';
for (let c = -70; c <= 90; c += 5){
const yy = py(c / 100), major = c % 10 === 0;
ctx.beginPath(); ctx.moveTo(rx + .5, yy); ctx.lineTo(rx + (major ? 9 : 4.5), yy); ctx.stroke();
if (major) ctx.fillText(String(c), rx + 13, yy);
}
ctx.fillStyle = INK(0.42);
ctx.fillText('cm', rx + 13, 12);
/* ghost of the initial hanging profile */
drawSlinky(yEq, 0.10, 0.05, 1, 1);
ctx.font = 'italic 10.5px ' + SERIF; ctx.fillStyle = INK(0.4);
ctx.textBaseline = 'middle';
ctx.fillText('where it hung at rest', cx + R + 16, py(yEq[30]));
/* marker line: height of the bottom end at the instant of release */
const ym = py(0);
ctx.strokeStyle = VERM; ctx.lineWidth = 1.2; ctx.setLineDash([7, 5]);
ctx.beginPath(); ctx.moveTo(0, ym); ctx.lineTo(W, ym); ctx.stroke();
ctx.setLineDash([]);
ctx.font = '9px ' + MONO; ctx.fillStyle = VERM;
ctx.textAlign = 'right'; ctx.textBaseline = 'bottom';
ctx.fillText('B O T T O M A T R E L E A S E', W - 14, ym - 6);
/* ceiling mount */
const yA = yEq[N], bw = Math.max(64, R * 3.6);
const yT = py(yA + 0.05), yB = py(yA + 0.012);
ctx.save();
ctx.beginPath(); ctx.rect(cx - bw / 2, yT, bw, yB - yT); ctx.clip();
ctx.strokeStyle = INK(0.45); ctx.lineWidth = 1;
for (let x = cx - bw / 2 - 24; x < cx + bw / 2 + 24; x += 6){
ctx.beginPath(); ctx.moveTo(x, yB + 3); ctx.lineTo(x + (yB - yT) + 6, yT - 3); ctx.stroke();
}
ctx.restore();
ctx.strokeStyle = INK(0.85); ctx.lineWidth = 2;
ctx.beginPath(); ctx.moveTo(cx - bw / 2, yB); ctx.lineTo(cx + bw / 2, yB); ctx.stroke();
ctx.fillStyle = INK(0.9);
ctx.beginPath(); ctx.arc(cx, yB, 2.4, 0, TAU); ctx.fill();
/* the slinky */
drawSlinky(y, 0.88, 0.28, Math.max(1.8, S * 0.0042), Math.max(1, S * 0.002));
/* datum: the bottom end */
ctx.fillStyle = VERM;
ctx.beginPath(); ctx.arc(cx, py(y[0]), 2.6, 0, TAU); ctx.fill();
}
function updateReadouts(){
if (!released){
rBot.textContent = '0.0';
rBotS.textContent = 'holding'; rBotS.className = 'lamp';
rFront.textContent = '— / 48';
rTop.textContent = '0.0'; rCom.textContent = '0.0'; rComA.textContent = '—';
return;
}
if (clkN) clkN.textContent = (simT * 1000).toFixed(1).padStart(6, '0');
rBot.textContent = ((yEq[0] - y[0]) * 1000).toFixed(1);
const still = Math.abs(v[0]) < 0.002 && Math.abs(y[0] - yEq[0]) < 2e-4;
rBotS.textContent = still ? 'holding' : 'falling';
rBotS.className = 'lamp' + (still ? '' : ' fall');
let f = -1;
for (let i = 0; i < M; i++){
if (Math.abs(v[i]) > 0.002 || Math.abs(y[i] - yEq[i]) > 2e-4){ f = i; break; }
}
rFront.textContent = (f < 0 ? '—' : String(f)) + ' / 48';
rTop.textContent = ((yEq[N] - y[N]) * 100).toFixed(1);
let s = 0;
for (let i = 0; i < M; i++) s += y[i];
rCom.textContent = ((comEq - s / M) * 100).toFixed(1);
const ac = comAccel();
rComA.textContent = isNaN(ac) ? '—' : ac.toFixed(2);
}
let lastT = performance.now();
function frame(now){
let wall = (now - lastT) / 1000;
lastT = now;
if (wall > 0.1) wall = 0.1;
if (wall < 0) wall = 0;
if (released) advance(wall * speed);
draw();
updateReadouts();
requestAnimationFrame(frame);
}
resetSim();
requestAnimationFrame(frame);
})();
</script>
</body>
</html>
What it actually shows
Plainly first: I cannot execute code in this setting, so I have not watched this file run. What I did instead was verify the model analytically — which is unusually strong here, because the model is exactly linear (forces are linear in separations and relative velocities, rest length 0), so its behaviour is a theorem, not a hope — and then transcribe that model directly into the code. My confidence is therefore conditional on my transcription being faithful, and I've built the instrument panel precisely so you can falsify me in five seconds.
What I am confident the file shows, and why: the bottom mass is driven only through segment 1, mass 1 only through segment 2, and so on; for this linear chain the response at a mass 48 links away from the release turns on at t ≈ N√(m/k) = 0.406 s (a Bessel-function turnover — exponentially small before, fast ramp after). So the bottom-end row should read a rock-solid 0.0 mm until ≈ 0.39–0.42 s, then depart rapidly. The COM row should read 9.80 flat from the first samples — under symplectic Euler the COM trajectory is exactly parabolic, so the second-difference readout is exact, and it doubles as a canary: if internal forces didn't cancel (a sign error, an explosion), it would leave 9.80 immediately. The top-end row should show the ≈ 49g start and the cap descending at roughly constant ~4 m/s.
Where I expect pixels to be rougher than my tidy prediction — said in advance: (1) the compressed cap will jitter: behind the front, adjacent coils ring in antiphase at ≈ 237 rad/s and the dashpot is deliberately weak (to keep the COM at exactly g), so the collapse looks chaotic rather than clean. That is real model physics, not instability — energy stays bounded and the COM row stays at 9.80. (2) From ~0.25 s the coils stream below the marker past the still-holding lower coils, because Hooke segments push as well as pull and there is no coil-contact constraint; a real slinky piles up on top of the bottom end instead. The levitation claim is unaffected, but the middle of the picture is where this model visibly differs from the table-top demo. (3) The bottom's departure is a ~40 ms ramp, so "0.0 until 0.41 s" may read as "0.0 until ~0.38 s, then quick".
Robustness: the speed slider cannot destabilize anything (it rescales simulated time, never Δt); at shipped settings the integrator has a 33× stability margin and there are no clamps to hide anything. If you edit k to ≳ 350 N/m without shortening Δt, it will eventually go unstable — visibly, and the COM row will betray it.
The falsification test: press Release at ×1. If the bottom-end row shows anything other than 0.0 mm before the clock reads ≈ 380 ms, or the COM row reads anything but 9.80 after release, my implementation is wrong and the prediction fails — I'd want to know that as much as you would.
Attachments
z-ai/glm-5.3-flash — page