Run Detail
completedglm-5.3-flashxRecorded 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
392.6s
Total Tokens
47,035
Input Tokens
743
Output Tokens
46,292
Reasoning Tokens
39,649
Reasoning Effort
default
Est. Cost
$0.0581
Started
9/22/2026, 4:46:47 AM
OR Provider
Z.AI
Finish Reason
stop
Generation ID
gen-1790052407-oIkvxUsWdseLeX5Wl6m7
Turns (1)
Turn #1
743 in46,292 out39,649 reasoning47,035 total392.5s
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
At the instant of release, nothing below the top coil can know the clamp is gone: every spring still carries its static hanging tension, and since that tension held every lower mass in balance, all forty-nine masses below the top still have exactly zero net force. The top coil, freed of the clamp, feels gravity plus the full 49·mg tension of the stretched spring beneath it, so it snaps downward with an initial acceleration of 50 g — within ~30 ms the first few coils have visibly closed. That collapse front then sweeps down the chain, fast through the widely-spaced, high-tension coils at the top, and slower in pixels through the bunched, barely-stretched coils near the bottom. The bottom end, meanwhile, does nothing: the spring above it still pulls up with exactly the one-mass weight it always carried. It sits on the marker line — displacement of at most a few pixels — for on the order of half a second; I commit to roughly 0.5–0.8 s of the sim's own time before it clearly drops. (My two analytic estimates for that hover time, √(S/g) ≈ 0.52 s from centre-of-mass bookkeeping of an ideal slinky, and Σ1/ω₀ ≈ 0.73 s from per-segment wave-crossing in the discrete chain, bracket exactly that range and disagree with each other by ~40% — which is part of why the exhibit is worth building.) When the front arrives, the supporting tension vanishes, the bottom sags away within a segment or two, and the whole slinky — now a compact lump level with the marker — falls at g, with the centre-of-mass instrument pinning at 1.00 g, leaving the frame around t ≈ 1.4 s at full speed. Top first, bottom last, marker untouched until the front gets there.
The setup
- Chain: 50 equal point masses (m = 1), 49 Hooke spring segments, natural length L₀ = 2.5 px, k = 4500 (screen-pixel force units). Motion is vertical (1-D).
- Gravity: g = 1400 px/s². Absolute scale on a screen is arbitrary; only ratios like √(S/g) are physical, so I state g so anyone can rescale.
- Damping: internal only. Each spring also carries a force c·(relative axial velocity), c = 4.0 — about 8% damping on the stiffest "accordion" mode, far less on slow modes, zero on statics. There is no global drag, so internal forces cancel pairwise and the centre of mass obeys a_cm = g exactly — which the instrument panel measures live so it can be checked rather than believed.
- Integrator: semi-implicit (symplectic) Euler, fixed h = 200 µs. Highest chain frequency ω_max = 2√(k/m) ≈ 134 rad/s, so ωh ≈ 0.027 against the explicit stability bound of 2 — a ~74× margin. Explicit damping factor c·h/m = 8×10⁻⁴. No velocity clamps, no force caps, nothing to hide an explosion with.
- Hanging equilibrium — solved, not relaxed: static balance says the spring between coil i and i+1 carries the weight of everything below it, T_i = (N−1−i)·m·g, so stretch Δ_i = T_i/k, positions accumulated from the anchor. Result: top gap ≈ 17.7 px, bottom gap ≈ 2.8 px — a 6:1 spacing ratio, like a real hanging slinky. Until Release, the top mass is pinned; that pin is the clamp, the one legitimate asymmetry. The sim runs live while held so you can see the hang is a genuine motionless equilibrium, not a pose. After Release, one force law drives all fifty masses identically.
- The playback slider changes only simulated-time-per-frame; h never changes, so stability is identical at 1× and 1/20×.
The file
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="utf-8">
<meta name="viewport" content="width=device-width,initial-scale=1">
<title>Exhibit 07 · The Falling Slinky</title>
<style>
:root{
--bg:#131518;--stage:#0e1013;--panel:#17191d;--hair:#262b31;--hair2:#333a42;
--ink:#d8d2c2;--dim:#8a8474;--faint:#565b63;
--brass:#c2a04c;--brass-hi:#ecd9a0;--red:#a24e31;--amber:#e2af4e;
--mono:ui-monospace,"Cascadia Mono","SF Mono",Consolas,"Liberation Mono",Menlo,monospace;
--serif:Georgia,"Iowan Old Style","Palatino Linotype",Palatino,"Times New Roman",serif;
}
*{box-sizing:border-box}
html,body{height:100%}
body{margin:0;background:var(--bg);color:var(--ink);font-family:var(--serif);display:flex;flex-direction:column;overflow:hidden}
header{display:flex;align-items:flex-end;justify-content:space-between;gap:24px;padding:16px 24px 14px;border-bottom:1px solid var(--hair)}
.kicker{font-family:var(--mono);font-size:10px;letter-spacing:.34em;color:var(--brass);text-transform:uppercase;margin-bottom:6px}
h1{margin:0;font-size:22px;font-weight:400;letter-spacing:.02em}
h1 em{font-style:italic;color:var(--brass-hi)}
.sub{font-family:var(--mono);font-size:11px;color:var(--dim);text-align:right;line-height:1.6;letter-spacing:.04em}
main{flex:1;display:grid;grid-template-columns:1fr 324px;min-height:0}
#stage{position:relative;background:var(--stage);border-right:1px solid var(--hair);min-height:0}
canvas{position:absolute;inset:0;display:block}
aside{background:var(--panel);overflow-y:auto;display:flex;flex-direction:column}
section{padding:16px 20px;border-bottom:1px solid var(--hair)}
.label{font-family:var(--mono);font-size:9.5px;letter-spacing:.26em;text-transform:uppercase;color:var(--dim);margin-bottom:8px}
#clock{font-family:var(--mono);font-size:38px;color:var(--amber);line-height:1;font-variant-numeric:tabular-nums}
#clock small{font-size:13px;color:var(--dim);letter-spacing:.15em;margin-left:6px}
.row{display:flex;justify-content:space-between;align-items:baseline;padding:5px 0;border-bottom:1px dotted #22262c}
.row:last-child{border-bottom:0}
.row .k{font-family:var(--mono);font-size:10px;letter-spacing:.18em;text-transform:uppercase;color:var(--dim)}
.row .v{font-family:var(--mono);font-size:14px;font-variant-numeric:tabular-nums}
.row .v span.hold{color:var(--brass-hi)}
#state{display:inline-block;padding:2px 8px;border:1px solid var(--hair2);font-family:var(--mono);font-size:10px;letter-spacing:.22em}
#state.free{color:var(--amber);border-color:#5a4a26}
button{font-family:var(--mono);font-size:11px;letter-spacing:.24em;text-transform:uppercase;color:var(--ink);background:transparent;border:1px solid var(--hair2);padding:12px 10px;cursor:pointer;transition:background .15s,border-color .15s}
button:hover:not(:disabled){background:#1d2126;border-color:#454c56}
button:disabled{opacity:.35;cursor:default}
button.primary{color:var(--brass-hi);border-color:#6b5a2e;flex:1.4}
.btns{display:flex;gap:8px}
.btns button{flex:1}
.spd{display:flex;justify-content:space-between;align-items:baseline;margin-bottom:4px}
#spdv{font-family:var(--mono);font-size:14px;color:var(--brass-hi)}
input[type=range]{-webkit-appearance:none;appearance:none;width:100%;height:28px;background:transparent;cursor:pointer;margin:0}
input[type=range]::-webkit-slider-runnable-track{height:2px;background:var(--hair2)}
input[type=range]::-webkit-slider-thumb{-webkit-appearance:none;width:13px;height:13px;margin-top:-5.5px;background:var(--brass);border:1px solid #0b0c0e}
input[type=range]::-moz-range-track{height:2px;background:var(--hair2)}
input[type=range]::-moz-range-thumb{width:12px;height:12px;background:var(--brass);border:1px solid #0b0c0e;border-radius:0}
.ticks{display:flex;justify-content:space-between;font-family:var(--mono);font-size:9.5px;color:var(--faint);letter-spacing:.1em}
.note{font-size:12.5px;line-height:1.65;color:var(--dim);font-style:italic}
footer{border-top:1px solid var(--hair);padding:9px 24px;display:flex;justify-content:space-between;gap:16px;font-family:var(--mono);font-size:10px;letter-spacing:.08em;color:var(--faint)}
@media(max-width:860px){
main{grid-template-columns:1fr;grid-template-rows:minmax(320px,1fr) auto}
#stage{border-right:0;border-bottom:1px solid var(--hair)}
.sub{display:none}
}
</style>
</head>
<body>
<header>
<div>
<div class="kicker">Exhibit 07 · Mechanics</div>
<h1>The Falling <em>Slinky</em></h1>
</div>
<div class="sub">fifty equal masses · forty-nine Hooke springs<br>released from true hanging equilibrium</div>
</header>
<main>
<div id="stage"><canvas id="cv"></canvas></div>
<aside>
<section>
<div class="label">Clock — since release</div>
<div id="clock">—<small>ms</small></div>
</section>
<section>
<div class="label">Instruments</div>
<div class="row"><span class="k">Bottom vs marker</span><span class="v" id="offv">—</span></div>
<div class="row"><span class="k">CM acceleration</span><span class="v" id="cmv">0.00 g</span></div>
<div class="row"><span class="k">State</span><span class="v"><span id="state">HELD</span></span></div>
</section>
<section>
<div class="label">Apparatus</div>
<div class="btns"><button id="bRel" class="primary">Release</button></div>
<div class="btns" style="margin-top:8px">
<button id="bPause">Pause</button>
<button id="bReset">Reset</button>
</div>
</section>
<section>
<div class="spd"><span class="label" style="margin:0">Playback speed</span><span id="spdv">1.00×</span></div>
<input type="range" id="spd" min="0" max="100" value="0" aria-label="playback speed">
<div class="ticks"><span>full speed</span><span>1/20</span></div>
</section>
<section>
<div class="note" id="note"></div>
</section>
</aside>
</main>
<footer>
<span>internal forces only ⇒ centre of mass falls at exactly g — measured live above</span>
<span>space — release · R — reset</span>
</footer>
<script>
'use strict';
/* ---------------------------------------------------------------
Model. One-dimensional vertical chain, y grows downward.
N masses, N-1 Hooke springs, gravity, internal axial damping.
Nothing else. No clamps, no per-mass branches after release.
---------------------------------------------------------------- */
const N = 50; // masses
const MASS = 1; // mass per bob (arbitrary units)
const K = 4500; // spring constant (force per px)
const L0 = 2.5; // natural length of one spring segment (px)
const G = 1400; // gravity (px/s^2)
const CDAMP = 4; // internal axial damping (force per relative velocity)
const DT = 2e-4; // fixed physics step: 200 microseconds
const WORLD_H = 900; // world height mapped to canvas height
const ANCHOR_Y = 70;
const cv = document.getElementById('cv'), ctx = cv.getContext('2d');
const stage = document.getElementById('stage');
const elClock = document.getElementById('clock'), elOff = document.getElementById('offv');
const elCm = document.getElementById('cmv'), elState = document.getElementById('state');
const elNote = document.getElementById('note'), elSpd = document.getElementById('spdv');
const spd = document.getElementById('spd');
const bRel = document.getElementById('bRel'), bPause = document.getElementById('bPause'),
bReset = document.getElementById('bReset');
const NOTE0 = 'The clamp holds the top coil. Every spring below carries exactly the weight hanging under it, so the coils crowd together at the top and nearly touch at the bottom — a true hanging equilibrium, not even spacing.';
const NOTE1 = 'Released. No pinned masses, no scripted coils — one law for all fifty. Watch the bottom against the marker: it has no reason to move until the collapse front reaches it.';
elNote.textContent = NOTE0;
/* ---------------- state ---------------- */
const y = new Float64Array(N), v = new Float64Array(N), f = new Float64Array(N);
let pinned = true, simT = 0, relT = -1, markerY = -1, paused = false, acc = 0;
let scl = 1, cssW = 0, cssH = 0, ax = 0, R = 60, divisor = 1;
let hist = [], aDisp = 0; // CM-velocity history and smoothed CM acceleration (measurement only)
function resize(){
const r = stage.getBoundingClientRect(), dpr = Math.min(window.devicePixelRatio || 1, 2);
cssW = Math.max(60, r.width); cssH = Math.max(60, r.height);
cv.width = Math.round(cssW * dpr); cv.height = Math.round(cssH * dpr);
scl = cssH / WORLD_H;
ax = cssW / scl / 2;
R = Math.min(88, Math.max(34, (cssW / scl) * 0.16));
}
new ResizeObserver(resize).observe(stage);
resize();
/* True hanging equilibrium, solved directly from static balance:
spring i (between coil i and i+1) carries the weight of all masses
below it, T_i = (N-1-i)*m*g, so its stretch is T_i/K. */
function hang(){
y[0] = ANCHOR_Y;
for(let i = 0; i < N - 1; i++) y[i+1] = y[i] + L0 + ((N - 1 - i) * MASS * G) / K;
v.fill(0);
}
/* One physics step: gravity + Hooke + internal damping, semi-implicit Euler.
Identical for every index. The only branch is the pre-release clamp on
mass 0 — which is the hand holding it. */
function step(h){
f.fill(0);
for(let i = 0; i < N; i++) f[i] += MASS * G;
for(let i = 0; i < N - 1; i++){
const t = K * ((y[i+1] - y[i]) - L0) + CDAMP * (v[i+1] - v[i]);
f[i] += t; f[i+1] -= t; // action–reaction pair: cancels in the CM sum
}
for(let i = 0; i < N; i++) v[i] += f[i] / MASS * h;
if(pinned){ v[0] = 0; y[0] = ANCHOR_Y; }
for(let i = 0; i < N; i++) y[i] += v[i] * h;
simT += h;
}
/* Passive measurement: CM acceleration by finite difference (display only,
never feeds back into the physics). Internal forces cancel pairwise,
so after release this must read 1.00 g. */
function measure(){
let s = 0; for(let i = 0; i < N; i++) s += v[i];
hist.push({ t: simT, vc: s / N });
if(hist.length > 600) hist.shift();
while(hist.length > 2 && simT - hist[0].t > 0.6) hist.shift();
const a = hist[hist.length - 1];
let j = 0; while(j < hist.length - 1 && a.t - hist[j].t > 0.15) j++;
const dt = a.t - hist[j].t;
if(dt > 0.03){ const cm = (a.vc - hist[j].vc) / dt; aDisp += (cm - aDisp) * 0.2; }
}
/* ---------------- controls ---------------- */
function release(){
if(!pinned) return;
markerY = y[N-1]; // marker line: bottom height at the instant of release
pinned = false; relT = simT;
bRel.disabled = true;
elState.textContent = 'FREE'; elState.classList.add('free');
elNote.textContent = NOTE1;
}
function reset(){
hang();
pinned = true; markerY = -1; relT = -1; simT = 0; acc = 0;
hist = []; aDisp = 0; paused = false;
bPause.textContent = 'Pause'; bRel.disabled = false;
elState.textContent = 'HELD'; elState.classList.remove('free');
elNote.textContent = NOTE0;
}
bRel.addEventListener('click', release);
bReset.addEventListener('click', reset);
bPause.addEventListener('click', () => { paused = !paused; bPause.textContent = paused ? 'Resume' : 'Pause'; });
spd.addEventListener('input', () => { divisor = 1 + 0.19 * (+spd.value); elSpd.textContent = (1 / divisor).toFixed(2) + '×'; });
window.addEventListener('keydown', e => {
if(e.code === 'Space' && !e.repeat){ e.preventDefault(); if(pinned) release(); }
if(e.code === 'KeyR') reset();
});
/* ---------------- rendering ---------------- */
const BUCKETS = 12, colB = [], colR = [], wid = [];
for(let b = 0; b < BUCKETS; b++){
const t = (b + 0.5) / BUCKETS, a = (0.5 + 0.45 * t).toFixed(3);
colB.push(`rgba(${Math.round(116+124*t)},${Math.round(97+120*t)},${Math.round(54+104*t)},${a})`);
colR.push(`rgba(${Math.round(140+92*t)},${Math.round(52+66*t)},${Math.round(34+48*t)},${a})`);
wid.push(1.8 + 1.7 * t);
}
const MONO = 'ui-monospace,Consolas,monospace';
function draw(){
const dpr = Math.min(window.devicePixelRatio || 1, 2);
ctx.setTransform(dpr, 0, 0, dpr, 0, 0);
ctx.fillStyle = '#0e1013'; ctx.fillRect(0, 0, cssW, cssH);
ctx.scale(scl, scl);
const W = cssW / scl;
/* side ruler */
ctx.font = '11px ' + MONO; ctx.textAlign = 'left'; ctx.textBaseline = 'middle'; ctx.lineWidth = 1;
for(let gy = 50; gy <= 850; gy += 50){
const major = gy % 100 === 0;
ctx.strokeStyle = major ? '#3d434b' : '#2b3037';
ctx.beginPath(); ctx.moveTo(major ? 14 : 19, gy); ctx.lineTo(24, gy); ctx.stroke();
if(major){ ctx.fillStyle = '#565b63'; ctx.fillText(String(gy), 28, gy); }
}
/* marker line — bottom of slinky at the instant of release */
if(markerY >= 0){
ctx.strokeStyle = '#a24e31'; ctx.lineWidth = 1.4; ctx.setLineDash([7, 6]);
ctx.beginPath(); ctx.moveTo(0, markerY); ctx.lineTo(W, markerY); ctx.stroke();
ctx.setLineDash([]);
ctx.fillStyle = '#a24e31'; ctx.textAlign = 'right';
ctx.fillText('BOTTOM AT RELEASE', W - 14, markerY - 9);
}
/* ceiling mount */
ctx.fillStyle = '#242930'; ctx.strokeStyle = '#3a4048'; ctx.lineWidth = 1;
ctx.fillRect(ax - 34, 40, 68, 8); ctx.strokeRect(ax - 34.5, 39.5, 69, 9);
ctx.strokeStyle = '#333a42';
for(let hx = ax - 32; hx <= ax + 26; hx += 8){
ctx.beginPath(); ctx.moveTo(hx, 38); ctx.lineTo(hx + 7, 26); ctx.stroke();
}
ctx.fillStyle = '#2b3037'; ctx.fillRect(ax - 3, 48, 6, 10);
/* the slinky: one continuous helix sampled through the true mass positions.
Fixed turns-per-segment, so stretched regions show wide coil spacing and
compressed regions bunch up. Bottom coil carries a painted red band. */
const TPS = 1.15, SAMP = 16;
let px = 0, py = 0, have = false;
for(let i = 0; i < N - 1; i++){
const y0 = y[i], y1 = y[i+1];
for(let sIdx = 0; sIdx <= SAMP; sIdx++){
if(i > 0 && sIdx === 0) continue;
const s = sIdx / SAMP, u = i + s, ph = u * TPS * 2 * Math.PI;
const d = Math.sin(ph);
const cx = ax + R * Math.cos(ph), cy = y0 + (y1 - y0) * s + R * 0.30 * d;
if(have){
const b = Math.max(0, Math.min(BUCKETS - 1, Math.floor((d + 1) * 0.5 * BUCKETS)));
ctx.strokeStyle = (u > N - 1.7 ? colR : colB)[b];
ctx.lineWidth = wid[b];
ctx.beginPath(); ctx.moveTo(px, py); ctx.lineTo(cx, cy); ctx.stroke();
}
px = cx; py = cy; have = true;
}
}
/* the clamp gripping the top coil — scenery only; slides away on release */
if(pinned || (relT >= 0 && simT - relT < 0.15)){
let e = pinned ? 0 : Math.min(1, (simT - relT) / 0.15); e = e * (2 - e);
ctx.globalAlpha = 1 - e;
ctx.fillStyle = '#454c56'; ctx.strokeStyle = '#5f6772'; ctx.lineWidth = 1;
const gx = R + 4 + e * 30;
ctx.fillRect(ax - gx - 4.5, ANCHOR_Y - 15, 9, 30);
ctx.strokeRect(ax - gx - 5, ANCHOR_Y - 15.5, 10, 31);
ctx.fillRect(ax + gx - 4.5, ANCHOR_Y - 15, 9, 30);
ctx.strokeRect(ax + gx - 5, ANCHOR_Y - 15.5, 10, 31);
ctx.globalAlpha = 1;
}
}
function hud(){
if(relT >= 0){
elClock.innerHTML = ((simT - relT) * 1000).toFixed(1) + '<small>ms</small>';
const off = y[N-1] - markerY;
elOff.textContent = (off >= 0 ? '+' : '') + off.toFixed(1) + ' px';
elOff.classList.toggle('hold', Math.abs(off) < 2);
} else {
elClock.innerHTML = '—<small>ms</small>';
elOff.textContent = '—';
elOff.classList.remove('hold');
}
elCm.textContent = (aDisp / G).toFixed(2) + ' g';
}
/* ---------------- main loop ---------------- */
let last = performance.now();
function frame(now){
const dt = Math.min((now - last) / 1000, 0.05); last = now;
if(!paused){
acc += dt / divisor; // slider rescales simulated time per frame only
let n = 0;
while(acc >= DT && n < 600){ step(DT); acc -= DT; n++; }
if(n >= 600) acc = 0; // never let the accumulator spiral
}
measure(); draw(); hud();
requestAnimationFrame(frame);
}
hang();
requestAnimationFrame(t => { last = t; frame(t); });
</script>
</body>
</html>
What it actually shows
First, the honest caveat: I have no runtime in this conversation, so I could not execute this file before handing it over. So I'll separate what is true by construction from what is estimate, and you should test both.
True by construction — checkable by reading the code, not by trusting me: the initial state is the algebraic equilibrium, spring i given stretch (N−1−i)·mg/k exactly, so at t=0⁺ all forty-nine masses below the top have net force zero to floating-point round-off. After release the loop applies gravity plus two spring terms identically to every index — no pins, no per-mass branches, no delays. Internal forces are action–reaction pairs whose sum is identically zero, so the CM readout must pin at 1.00 g during the fall; if it doesn't, I got it wrong. Stability margin is ~74× (ωh ≈ 0.027 vs. the bound of 2), and there is no velocity clamp anywhere to mask an explosion.
What I believe you'll see, with numbers I'd defend to ±30%: the top snaps down within the first few frames; the bottom sits on the marker — the "Bottom vs marker" field reading under a few pixels — for somewhere in 0.5–0.8 s of sim time, then drops, and everything leaves the frame around 1.4 s. I want to flag that my two estimates for the hover time genuinely disagree by ~40% (√(S/g) ≈ 0.52 s vs. Σ1/ω₀ ≈ 0.73 s), and I don't know which side the discrete sim lands on; the clock plus that readout field will settle it. The mechanism — top-first collapse, stationary bottom until the front arrives — doesn't depend on which is right, because it follows from the equilibrium arithmetic alone.
Deviations I expect you to catch: (1) the bottom is not mathematically frozen — a discrete lattice is dispersive, so a low-amplitude tail arrives before the front; expect roughly 1–5 px of slow creep before the drop, most visible at 1/20×, where the hover stretches to 10–16 s. (2) The front is a few segments wide, not a knife edge, and it decelerates in pixel terms through the barely-stretched bottom coils. (3) My springs push as well as pull — a real slinky buckles and cannot push — so the collapsed lump keeps a small shudder, damped out in a few tenths of a second; a tension-only model would kill it but injects snap-taut impulses I trust less. (4) The bottom's departure is a fast sag-then-fall over a segment or two, not an instant release.
Robustness: stability is identical across the whole speed slider because the step size never changes. I have not tested other k or c values at runtime, so I only claim stability for the shipped values — though with two orders of magnitude of step-size headroom, I'd expect it to hold well beyond them. And if you press Release and the bottom leaves the marker in the first 100 ms, or the top doesn't snap — my implementation is broken, not the physics, and I'd want to know.
Attachments
z-ai/glm-5.3-flashx — page