Run Detail
completedclaude-opus-5.5Recorded 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
Batched — not timed
Total Tokens
32,642
Input Tokens
1,074
Output Tokens
31,568
Reasoning Tokens
22,208
Reasoning Effort
default
Est. Cost
$0.3178
Started
9/22/2026, 11:51:14 PM
OR Provider
Anthropic
Finish Reason
stop
Generation ID
gen-batch-1790121075-82342913117c20e434db
Turns (1)
Turn #1
1,074 in31,568 out22,208 reasoning32,642 total
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
The bottom of the slinky will not move at all, to within a micrometre, for about 260 ms after release. It hangs on the marker line while the top comes down to meet it.
- Why the bottom stays put. The bottom coil is held up only by the tension in the spring just above it. That tension cannot change until news of the release arrives. The news travels down the coils as a collapse front: the coils above it are packed into a closed block, and the coils below it do not yet know anything has happened.
- Why nothing runs ahead of the front. The front moves at least as fast as ordinary waves in the stretched coils, so no signal outruns it.
- What the top does. The top coil starts with an acceleration of about N·g, roughly 60 g for 60 coils. Within a few milliseconds it reaches about g√(M/k) ≈ 4.4 m/s. It then sweeps down at a steady, slowly falling speed, dropping to about 2.5 m/s, as the block collects more coils.
- When the front reaches the bottom. The only external force after release is gravity, so the moving block carries momentum M·g·t. Combining that with the hanging profile gives t_c = √(M/3k)·√(1+1/N). With M = 0.2 kg, k = 1 N/m and N = 60, that is ≈ 260 ms (258 ms in the continuum limit).
- The centre of mass falls exactly ½gt² the whole time, about 0.33 m at t_c.
- After that, the closed slinky falls as one piece at g, starting from about g·t_c ≈ 2.5 m/s.
The setup
- Segments: N = 60 point masses (one per coil) joined by 59 springs.
- Mass: total M = 0.20 kg, so m = M/N ≈ 3.33 g per coil.
- Springs: each spring has k_s = 59 N/m, so the whole slinky is k = 1.0 N/m.
- The force is Hooke's law, k_s·(d − d₀), for gaps d ≥ d₀.
- The closed length is d₀ = 1.5 mm per gap, giving a collapsed slinky 8.9 cm long.
- There is no pre-tension.
- Coil contact: below the closed length, coils push each other apart. This is a one-sided contact spring (k_c = 2×10⁵ N/m) plus a contact dashpot (c_c = 30 N·s/m, about 0.8 of critical, so collisions are nearly inelastic).
- The contact force is prevented from becoming attractive, because touching coils can push but not pull. This limits a force, never a velocity.
- It is applied identically to every neighbouring pair.
- Damping: a small dashpot between neighbours on the stretched springs, c_s = 0.005 N·s/m.
- All damping acts on relative velocity between neighbours, so it cannot slow the centre of mass.
- Air-drag-style damping would slow the centre of mass, and the ½gt² check on the page would expose it.
- Integrator: symplectic (semi-implicit) Euler, with a fixed step Δt = 10 µs.
- The stiffest mode of the chain is ω_max ≈ 2√(k_c/m) ≈ 15,500 rad/s. The stability limit is Δt < 2/ω_max ≈ 130 µs, so the step has a safety margin of about 13×.
- Each frame runs a whole number of steps set by (frame time × speed). The clock is simply the step count × Δt.
- Hanging equilibrium: solved exactly, not relaxed into.
- Gap i (counting from the top) carries the weight of the coils below it, so its tension is (N−1−i)·m·g.
- Its length is therefore d₀ + (N−1−i)·m·g/k_s. At rest the top gap is 34.2 mm and the bottom gap is 1.5 mm.
- The total hanging length is 0.981 m of stretch plus 0.089 m closed length, about 1.07 m.
- While held, the state is still being simulated, with the top coil clamped. The page reports the leftover net force on every coil at the moment of reset (floating-point level), so you can see it truly is at rest.
- Special cases: there is exactly one.
- Before release, coil 0 is held fixed; that is the hanging point.
- Release turns that off, and from then on no coil is treated differently from any other.
- The drawing and readouts single out the top and bottom coils for display only.
- The simulation stops at 700 ms purely to save CPU, because by then the slinky has left the chart.
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>
html,body{margin:0;background:#111418;color:#e6e6e6;font:14px/1.45 system-ui,-apple-system,"Segoe UI",Roboto,sans-serif}
#wrap{max-width:980px;margin:0 auto;padding:12px}
h1{font-size:20px;margin:4px 0 10px;font-weight:600}
#controls{display:flex;flex-wrap:wrap;gap:10px;align-items:center;margin-bottom:8px}
button{font:inherit;padding:6px 16px;border-radius:6px;border:1px solid #556;background:#243044;color:#fff;cursor:pointer}
button:hover:not(:disabled){background:#2f3f5a}
button:disabled{opacity:.4;cursor:default}
#release{background:#7a2b2b;border-color:#a44}
#release:hover:not(:disabled){background:#943535}
label{display:flex;align-items:center;gap:6px}
input[type=range]{width:180px}
#clock{font:600 18px ui-monospace,Menlo,Consolas,monospace;margin-left:auto;color:#ffd479}
canvas{display:block;width:100%;max-width:960px;height:auto;background:#0b0e12;border:1px solid #2a2f38;border-radius:6px}
#readouts{display:grid;grid-template-columns:repeat(auto-fit,minmax(290px,1fr));gap:4px 18px;margin-top:8px;font:13px ui-monospace,Menlo,Consolas,monospace;color:#cfd6df}
#readouts b{color:#fff;font-weight:600}
.note{color:#8a94a3;font-size:12px;margin-top:8px}
</style>
</head>
<body>
<div id="wrap">
<h1>The falling slinky — 60 coils, masses & Hooke springs, no scripting</h1>
<div id="controls">
<button id="release">Release</button>
<button id="pause" disabled>Pause</button>
<button id="reset">Reset</button>
<label>Speed <input id="speed" type="range" min="0" max="100" value="100"> <span id="speedLabel">1× (real time)</span></label>
<span id="clock">t = 0.0 ms</span>
</div>
<canvas id="c" width="960" height="760"></canvas>
<div id="readouts"></div>
<div class="note">
Model: 60 point masses (M = 0.20 kg), 59 springs (k<sub>s</sub> = 59 N/m each, whole slinky k = 1 N/m, closed gap 1.5 mm),
stiff one-sided coil contact, small inter-coil damping, symplectic Euler, Δt = 10 µs.
Hanging state is the exact static equilibrium. After Release every coil obeys identical rules.
The chart shares the vertical scale of the slinky: it plots height against time.
</div>
</div>
<script>
"use strict";
// ---------------- physical parameters ----------------
const N = 60; // coils (point masses)
const M = 0.20; // total mass, kg
const m = M / N; // mass per coil
const K_TOTAL = 1.0; // stiffness of whole slinky, N/m
const KS = K_TOTAL*(N-1); // stiffness of each of the N-1 springs
const D0 = 0.0015; // closed (rest) gap between coils, m
const KC = 2.0e5; // contact stiffness when coils are pressed together, N/m
const CC = 30; // contact dashpot, N s/m
const CS = 0.005; // small inter-coil damping on the stretched spring, N s/m
const G = 9.81; // m/s^2
const DT = 1.0e-5; // integration step, s
const T_END = 0.70; // stop simulating (off chart) after this, s
const TC_THEORY = Math.sqrt(M*(N+1)/(3*K_TOTAL*N)); // rigid-contact prediction, discrete chain
// ---------------- state ----------------
const y = new Float64Array(N); // position, metres, measured DOWNWARD from the hanging point
const v = new Float64Array(N);
const a = new Float64Array(N);
let held = true, released = false, paused = false, finished = false;
let steps = 0, t = 0;
let bottom0 = 0, top0 = 0, com0 = 0, marker = null;
let moved1um = null, moved1mm = null;
let history = [];
let residual = 0;
let speed = 1, acc = 0;
function com(){ let s=0; for(let i=0;i<N;i++) s+=y[i]; return s/N; }
function equilibrium(){
// Gap i (between coil i and i+1) carries the weight of coils i+1..N-1.
y[0] = 0;
for(let i=0;i<N-1;i++) y[i+1] = y[i] + D0 + (N-1-i)*m*G/KS;
v.fill(0);
}
function forces(){
for(let i=0;i<N;i++) a[i] = G;
for(let i=0;i<N-1;i++){
const d = y[i+1]-y[i];
const dv = v[i+1]-v[i];
let f; // positive = tension pulling the pair together
if(d >= D0){
f = KS*(d-D0) + CS*dv;
} else {
let r = KC*(D0-d) - CC*dv; // contact repulsion (spring + dashpot)
if(r < 0) r = 0; // touching coils can push, not pull
f = -r;
}
a[i] += f/m;
a[i+1] -= f/m;
}
if(held) a[0] = 0; // the hanging point, only before Release
}
function step(){
forces();
for(let i=0;i<N;i++){ v[i] += a[i]*DT; y[i] += v[i]*DT; }
if(held){ v[0]=0; y[0]=0; }
}
function reset(){
held = true; released = false; paused = false; finished = false;
steps = 0; t = 0; acc = 0; marker = null; moved1um = null; moved1mm = null; history = [];
equilibrium();
forces();
residual = 0;
for(let i=1;i<N;i++) residual = Math.max(residual, Math.abs(a[i]*m));
btnRelease.disabled = false; btnPause.disabled = true; btnPause.textContent = "Pause";
}
function release(){
if(released) return;
held = false; released = true; steps = 0; t = 0; acc = 0;
bottom0 = y[N-1]; top0 = y[0]; com0 = com();
marker = bottom0;
history = [[0, y[0], y[N-1], com0]];
btnRelease.disabled = true; btnPause.disabled = false;
}
// ---------------- UI ----------------
const btnRelease = document.getElementById('release');
const btnPause = document.getElementById('pause');
const btnReset = document.getElementById('reset');
const slider = document.getElementById('speed');
const speedLabel = document.getElementById('speedLabel');
const clockEl = document.getElementById('clock');
const readEl = document.getElementById('readouts');
btnRelease.onclick = release;
btnReset.onclick = reset;
btnPause.onclick = () => { paused = !paused; btnPause.textContent = paused ? "Resume" : "Pause"; };
function setSpeed(){
speed = Math.pow(20, (slider.value-100)/100); // 1 .. 1/20, logarithmic
speedLabel.textContent = speed > 0.995 ? "1\u00d7 (real time)" : "1/" + (1/speed).toFixed(1) + "\u00d7";
}
slider.oninput = setSpeed; setSpeed();
// ---------------- drawing ----------------
const cv = document.getElementById('c');
const ctx = cv.getContext('2d');
const W = 960, H = 760;
function resize(){
const dpr = window.devicePixelRatio || 1;
cv.width = W*dpr; cv.height = H*dpr;
ctx.setTransform(dpr,0,0,dpr,0,0);
}
window.addEventListener('resize', resize); resize();
const Y0 = 50, SCALE = 300; // px at hanging point, px per metre
const sy = w => Y0 + w*SCALE;
const CX = 200, RX = 70, RY = 5; // slinky drawing
const X0 = 390, X1 = 935, TMAX = 0.70; // chart
const tx = s => X0 + (s/TMAX)*(X1-X0);
function draw(){
ctx.fillStyle = '#0b0e12'; ctx.fillRect(0,0,W,H);
// ruler (metres below hanging point)
ctx.strokeStyle = '#3a414c'; ctx.fillStyle = '#7d8795'; ctx.lineWidth = 1;
ctx.font = '11px ui-monospace,Menlo,Consolas,monospace';
for(let k=0;k<=23;k++){
const yy = sy(k*0.1);
if(yy > H) break;
ctx.beginPath(); ctx.moveTo(40,yy); ctx.lineTo(k%5===0?58:50,yy); ctx.stroke();
if(k%5===0) ctx.fillText((k/10).toFixed(1)+' m', 4, yy+4);
}
ctx.beginPath(); ctx.moveTo(40,Y0); ctx.lineTo(40,H); ctx.stroke();
// ceiling and clamp
ctx.fillStyle = '#6b7380'; ctx.fillRect(CX-95, Y0-22, 190, 8);
if(held){
ctx.fillStyle = '#9aa3af'; ctx.fillRect(CX-5, Y0-14, 10, 12);
} else {
ctx.fillStyle = '#4a515c'; ctx.fillRect(CX-5, Y0-14, 10, 5);
}
// marker line at bottom-at-release
if(marker !== null){
ctx.save();
ctx.strokeStyle = '#ff5a5a'; ctx.setLineDash([8,6]); ctx.lineWidth = 1.5;
ctx.beginPath(); ctx.moveTo(60, sy(marker)); ctx.lineTo(W-10, sy(marker)); ctx.stroke();
ctx.restore();
ctx.fillStyle = '#ff7a7a'; ctx.font = '12px system-ui,sans-serif';
ctx.fillText('bottom of slinky at release', 64, sy(marker)-6);
}
// coils
ctx.lineWidth = 1.6;
for(let i=0;i<N;i++){
const hue = 200 - 160*i/(N-1);
ctx.strokeStyle = `hsl(${hue},75%,62%)`;
ctx.beginPath(); ctx.ellipse(CX, sy(y[i]), RX, RY, 0, 0, 2*Math.PI); ctx.stroke();
}
// centre of mass tick
const ycm = sy(com());
ctx.fillStyle = '#ffffff';
ctx.beginPath(); ctx.moveTo(CX+RX+22, ycm); ctx.lineTo(CX+RX+34, ycm-6); ctx.lineTo(CX+RX+34, ycm+6); ctx.closePath(); ctx.fill();
ctx.font = '12px system-ui,sans-serif'; ctx.fillText('CM', CX+RX+38, ycm+4);
// chart: height vs time, sharing the slinky's vertical scale
ctx.strokeStyle = '#262c35'; ctx.lineWidth = 1; ctx.fillStyle = '#7d8795';
ctx.font = '11px ui-monospace,Menlo,Consolas,monospace';
for(let ms=0; ms<=700; ms+=100){
const xx = tx(ms/1000);
ctx.beginPath(); ctx.moveTo(xx, Y0); ctx.lineTo(xx, H-22); ctx.stroke();
ctx.fillText(ms+' ms', xx-18, H-8);
}
// theory line
ctx.save(); ctx.strokeStyle = '#8a6d2c'; ctx.setLineDash([3,4]);
ctx.beginPath(); ctx.moveTo(tx(TC_THEORY), Y0); ctx.lineTo(tx(TC_THEORY), H-22); ctx.stroke(); ctx.restore();
ctx.fillStyle = '#c9a24a'; ctx.fillText('predicted t_c = '+(TC_THEORY*1000).toFixed(0)+' ms', tx(TC_THEORY)+4, Y0+12);
if(history.length > 1){
// free fall reference for CM
ctx.save(); ctx.strokeStyle = 'rgba(255,255,255,0.45)'; ctx.setLineDash([5,5]); ctx.lineWidth = 1.2;
ctx.beginPath();
for(let k=0;k<=100;k++){
const s = t*k/100; const xx = tx(s), yy = sy(com0 + 0.5*G*s*s);
if(k===0) ctx.moveTo(xx,yy); else ctx.lineTo(xx,yy);
}
ctx.stroke(); ctx.restore();
const series = [[1,'#ffab40'],[2,'#4dd0e1'],[3,'#ffffff']];
for(const [col,colr] of series){
ctx.strokeStyle = colr; ctx.lineWidth = col===3?1.3:2;
ctx.beginPath();
for(let k=0;k<history.length;k++){
const h = history[k]; const xx = tx(h[0]), yy = sy(h[col]);
if(k===0) ctx.moveTo(xx,yy); else ctx.lineTo(xx,yy);
}
ctx.stroke();
}
}
// legend
const lg = [['#ffab40','top coil'],['#4dd0e1','bottom coil'],['#ffffff','centre of mass'],['rgba(255,255,255,0.5)','\u00bdgt\u00b2 from rest (dashed)']];
ctx.font = '12px system-ui,sans-serif';
lg.forEach(([c,s],k)=>{
ctx.fillStyle = c; ctx.fillRect(X1-170, H-150+k*18, 16, 3);
ctx.fillStyle = '#cfd6df'; ctx.fillText(s, X1-148, H-145+k*18);
});
// big clock on canvas
ctx.fillStyle = '#ffd479'; ctx.font = '600 26px ui-monospace,Menlo,Consolas,monospace';
ctx.fillText((t*1000).toFixed(1).padStart(6,' ')+' ms', X1-190, 36);
ctx.font = '12px system-ui,sans-serif'; ctx.fillStyle = '#8a94a3';
ctx.fillText(held ? 'hanging (held at top)' : (finished ? 'run ended' : (paused ? 'paused' : 'falling')), X1-190, 52);
}
function fmtT(x){ return x===null ? '\u2014' : (x*1000).toFixed(2)+' ms'; }
function updateReadouts(){
clockEl.textContent = 't = ' + (t*1000).toFixed(1) + ' ms';
const topGap = (y[1]-y[0])*1000, botGap = (y[N-1]-y[N-2])*1000;
let html = '';
if(!released){
html += `<div>equilibrium residual force: <b>${residual.toExponential(1)} N</b></div>`;
html += `<div>top gap / bottom gap at rest: <b>${topGap.toFixed(1)} mm / ${botGap.toFixed(2)} mm</b></div>`;
html += `<div>hanging length: <b>${((y[N-1]-y[0])*100).toFixed(1)} cm</b></div>`;
html += `<div>predicted collapse time: <b>${(TC_THEORY*1000).toFixed(1)} ms</b></div>`;
} else {
const db = y[N-1]-bottom0, dcm = com()-com0, ff = 0.5*G*t*t;
html += `<div>bottom coil displacement: <b>${(db*1e6).toFixed(2)} \u00b5m</b></div>`;
html += `<div>top coil displacement: <b>${((y[0]-top0)*1000).toFixed(1)} mm</b> (v = ${v[0].toFixed(2)} m/s)</div>`;
html += `<div>CM drop: <b>${(dcm*1000).toFixed(2)} mm</b> vs \u00bdgt\u00b2 = ${(ff*1000).toFixed(2)} mm</div>`;
html += `<div>bottom first moved >1 \u00b5m at: <b>${fmtT(moved1um)}</b></div>`;
html += `<div>bottom first moved >1 mm at: <b>${fmtT(moved1mm)}</b></div>`;
html += `<div>predicted (rigid-contact limit): <b>${(TC_THEORY*1000).toFixed(1)} ms</b></div>`;
}
readEl.innerHTML = html;
}
// ---------------- main loop ----------------
let last = performance.now();
function frame(now){
const dtReal = Math.min((now-last)/1000, 1/30); last = now;
if(!paused && !finished){
acc += dtReal*speed;
let n = Math.floor(acc/DT); acc -= n*DT;
if(n > 6000) n = 6000;
for(let k=0;k<n;k++){
step();
if(released){
steps++; t = steps*DT;
const db = Math.abs(y[N-1]-bottom0);
if(moved1um===null && db > 1e-6) moved1um = t;
if(moved1mm===null && db > 1e-3) moved1mm = t;
if(steps % 50 === 0) history.push([t, y[0], y[N-1], com()]);
if(t >= T_END){ finished = true; history.push([t, y[0], y[N-1], com()]); btnPause.disabled = true; break; }
}
}
}
draw();
updateReadouts();
requestAnimationFrame(frame);
}
reset();
requestAnimationFrame(frame);
</script>
</body>
</html>
What it actually shows
I have not seen this run. I cannot execute code here, so everything below is my own checking of the code and the physics. It is not an observation. The page measures the things that could prove me wrong, and those readouts are what you should believe over this section.
What I checked by hand:
- Equilibrium. Coil j feels gravity mg plus a pull down of (N−1−j)mg from the spring below and a pull up of (N−j)mg from the spring above. That nets to zero exactly, and the page prints the residual force (should be about 1e-16 N).
- Force signs in both the stretched-spring branch and the contact branch.
- Stability margin, as described in the setup (about 13×).
- The momentum argument. It gives the 260 ms figure, and it also correctly predicts that the centre of mass has fallen by one third of the stretched length at that moment.
- No special cases after release. The only
if (held)in the physics is the clamp, and it ends at Release.
What I expect to see, and how confident I am:
- Bottom stays on the marker until roughly 250–270 ms. I am fairly confident. The two readouts, "bottom first moved > 1 µm" and "> 1 mm", will give you the actual number.
- The 260 ms figure assumes perfectly inelastic, instantaneous coil collisions.
- My contact is stiff but finite, and slightly bouncy (restitution around 1%), so the real figure could differ by a few percent. I cannot tell you the sign of that difference without running it.
- The 1 µm threshold may trip slightly before the 1 mm one. The discrete chain lets a tiny leading edge of motion arrive a little ahead of the front. I expect that gap to be well under a millisecond, but I am unsure.
- Centre of mass tracks ½gt². I expect agreement to within about 0.01 mm, because all damping and contact forces are internal. If that readout drifts visibly, something in the code is wrong.
- Top trace: a near-instant jump to about 4 m/s, then a slightly concave, decelerating line. This follows from the momentum argument, but I have not seen it drawn. The first few coils may make it a little ragged as they rattle into the block.
Where it could break:
- Coils may visibly overlap. At the first impact (about 4.4 m/s), I estimate each contact squeezes about 0.4 mm into a 1.5 mm gap. On screen, closed coils sit less than 1 px apart, so an overlapping blob is expected. Much harder impacts than I estimated would make the overlap worse.
- Lowering the contact stiffness by 10× or more would let coils interpenetrate badly. The collapse front would then soften and the timing would move.
- Raising the time step above about 100 µs will make it blow up. I deliberately did not add anything to hide that.
Where it departs from a real slinky:
- No pre-tension. A real slinky's bottom few coils hang pressed together, and my equilibrium lacks that. Its timing against a real toy is therefore approximate, even if it is correct for its own model.
- The contact force can push but never pull. Contact is one-sided, which is a force law applied identically to every pair of neighbours, not a velocity clamp.
If the "bottom first moved" readout comes out far from about 260 ms, for example near 450 ms, the collapse is not behaving like an inelastic pile-up. That would mean my contact model is wrong, not the physics, and I would want to know.
Attachments
anthropic/claude-opus-5.5 — page