Run Detail
completedunion-alphaRecorded 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
267.6s
Total Tokens
9,101
Input Tokens
751
Output Tokens
8,350
Reasoning Effort
default
Est. Cost
$0.0000
Started
9/16/2026, 11:35:56 PM
OR Provider
Stealth
Finish Reason
stop
Generation ID
gen-1789601756-H5FzYAp1wHwRFGGoEa5Z
Turns (1)
Turn #1
751 in8,350 out9,101 total267.6s
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 top will accelerate downward immediately after release: its initial acceleration is (64g), because its own weight and the spring tension below it both pull downward. It should descend roughly 25 cm in the first 100 ms and 40 cm in the first 200 ms. The bottom should remain essentially at the marker during those first 200 ms—not because it is constrained, but because its upward spring force still nearly balances its weight. The release disturbance travels down the chain, reaching the bottom over roughly 280–350 ms; the characteristic travel time is 315 ms. Around then, the bottom should begin falling noticeably. A finite, damped spring chain has a spreading disturbance rather than a perfectly sharp front, so “stationary” here means negligible displacement, not mathematically exact immobility.
The setup
- 64 equal masses, 63 spring segments, moving vertically.
- Mass: 0.003 kg each; gravity: 9.81 m/s².
- Every spring: stiffness 120 N/m, natural length 0.020 m.
- Every neighbouring pair: viscous damping 0.012 N·s/m, acting on relative velocity, with equal and opposite forces.
- Integrator: fourth-order Runge–Kutta, fixed timestep 0.25 ms. The largest undamped angular frequency is approximately 400 rad/s, giving (\omega_{\max}\Delta t \approx 0.10).
- Exact hanging equilibrium: spring (i), numbered from zero at the top, supports (63-i) masses: [ y_{i+1}-y_i=\ell_0+\frac{(63-i)mg}{k}. ] All initial velocities are zero. The hanging length is approximately 1.754 m.
- After release, every mass uses the same force calculation and integrator. There are no constraints, contact rules, velocity clamps, or timed changes.
This is an ideal Hookean slinky with finite natural pitch, not a close-packed coil-contact model. Springs can carry compression; coil impacts and the later formation of a solid stack are not modelled.
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 {
color-scheme: dark;
font-family: system-ui, -apple-system, BlinkMacSystemFont, "Segoe UI", sans-serif;
background: #101722;
color: #edf3ff;
}
* { box-sizing: border-box; }
body { margin: 0; padding: 22px 14px; }
main { max-width: 960px; margin: auto; }
h1 { margin: 0 0 7px; font-size: clamp(1.6rem, 4vw, 2.3rem); }
p { line-height: 1.5; }
.intro { margin: 0 0 18px; color: #b9c9df; }
.controls {
display: flex; flex-wrap: wrap; align-items: center;
gap: 12px; padding: 14px;
background: #1b2738; border-radius: 12px 12px 0 0;
}
button {
border: 1px solid #7397ba; border-radius: 7px;
background: #294260; color: white; padding: 10px 18px;
font: inherit; font-weight: 650; cursor: pointer;
}
button.primary { background: #9be2f3; color: #10232f; }
button:disabled { opacity: .45; cursor: default; }
button:focus-visible, input:focus-visible, summary:focus-visible {
outline: 3px solid #ffd77f; outline-offset: 4px;
}
.speed {
display: flex; flex: 1 1 260px; align-items: center;
gap: 10px; min-width: 240px;
}
input[type=range] { flex: 1; min-width: 90px; accent-color: #9be2f3; }
output { min-width: 4.6em; font-variant-numeric: tabular-nums; }
.clock {
padding: 8px 12px; background: #0d1725; border-radius: 7px;
font-variant-numeric: tabular-nums; white-space: nowrap;
}
#clock { display: inline-block; min-width: 6ch; text-align: right; }
canvas {
display: block; width: 100%; height: clamp(470px, 70vh, 690px);
background: #101c2b; border: 1px solid #304259;
}
.readouts {
display: flex; flex-wrap: wrap; gap: 8px 24px;
padding: 12px 14px; background: #1b2738;
border-radius: 0 0 12px 12px; font-size: .92rem;
font-variant-numeric: tabular-nums;
}
#status { flex: 1 1 100%; color: #ffd77f; }
.note { font-size: .92rem; color: #b9c9df; }
details {
margin-top: 14px; padding: 14px; border: 1px solid #304259;
border-radius: 9px; background: #152131;
}
summary { cursor: pointer; font-weight: 650; }
table {
width: 100%; border-collapse: collapse; margin-top: 14px;
font-size: .9rem; font-variant-numeric: tabular-nums;
}
th, td {
text-align: right; padding: 8px 6px;
border-bottom: 1px solid #304259;
}
th:first-child, td:first-child { text-align: left; }
.small { font-size: .85rem; color: #b9c9df; line-height: 1.5; }
</style>
</head>
<body>
<main>
<h1>The falling slinky</h1>
<p class="intro">
Watch the bottom against the gold line. Nothing holds it after release.
</p>
<div class="controls">
<button id="release" class="primary" type="button">Release</button>
<button id="reset" type="button">Reset</button>
<label class="speed">
<span>Speed</span>
<input id="speed" type="range" min="0" max="100" value="100"
aria-label="Playback speed, one twentieth to full speed">
<output id="speedValue" for="speed">1.00×</output>
</label>
<div class="clock">t = <span id="clock">0.0</span> ms</div>
</div>
<canvas id="canvas"
aria-label="Vertical spring-mass slinky. The gold horizontal line marks the bottom at release.">
Your browser needs canvas support to draw this demonstration.
</canvas>
<div class="readouts">
<span>Top drop: <strong id="topDrop">0.00</strong> mm</span>
<span>Bottom drop: <strong id="bottomDrop">0.00</strong> mm</span>
<span>COM error: <strong id="comError">0.000</strong> mm</span>
<span id="status" role="status">Hanging in exact static equilibrium.</span>
</div>
<p class="note">
64 masses · 63 identical springs · downward is positive.
Speed changes elapsed simulation time, not gravity or the integration step.
The view does not follow the falling slinky; eventually it falls out of sight.
Hidden tabs pause playback.
</p>
<details>
<summary>Physics and numerical checks</summary>
<p class="small">
m = 0.003 kg, k = 120 N/m, natural spring length = 0.020 m,
neighbour damping = 0.012 N·s/m, g = 9.81 m/s².
Fixed-step RK4 with Δt = 0.00025 s.
Each pair exerts F = k(y[j] − y[i] − ℓ₀) + c(v[j] − v[i])
downward on i and upward on j. There is no air drag.
</p>
<p class="small">
Initially spring i supports all 63 − i masses below it.
Only the top is supported before release. Afterwards, the force loop
has no pinned masses and no end-specific rules.
This is a linear elastic model, without coil contact or impacts.
The horizontal width of the drawing is illustrative; the dynamics are vertical.
</p>
<p class="small">
The table below is calculated on page load by a separate copy of the
same numerical model. It is not a recorded trajectory and does not
drive the animation. Positive drop means downward displacement.
Its last column compares the standard step with a halved step.
</p>
<table>
<thead>
<tr>
<th>Time</th>
<th>Top drop</th>
<th>Bottom drop</th>
<th>Max position difference*</th>
</tr>
</thead>
<tbody id="checks"></tbody>
</table>
<p id="checkSummary" class="small"></p>
<p class="small">
*Across all masses, comparing 0.25 ms and 0.125 ms steps.
The live COM error compares the numerical centre-of-mass drop with
½gt². Internal spring and damping forces cancel, so this is an
independent force-balance check, not a correction applied to the motion.
</p>
</details>
</main>
<script>
"use strict";
(() => {
const N = 64;
const M = 0.003;
const K = 120;
const L0 = 0.020;
const C = 0.012;
const G = 9.81;
const DT = 0.00025;
// Coordinates are metres downward from the support.
const hanging = new Float64Array(N);
for (let i = 0; i < N - 1; i++) {
hanging[i + 1] = hanging[i] + L0 + (N - 1 - i) * M * G / K;
}
const hangingLength = hanging[N - 1];
function mean(a) {
let total = 0;
for (let i = 0; i < N; i++) total += a[i];
return total / N;
}
const initialCOM = mean(hanging);
function makeState() {
return {
y: new Float64Array(hanging),
v: new Float64Array(N),
ty: new Float64Array(N),
tv: new Float64Array(N),
ky: Array.from({ length: 4 }, () => new Float64Array(N)),
kv: Array.from({ length: 4 }, () => new Float64Array(N)),
ticks: 0
};
}
// This force function is used unchanged for every RK4 stage after release.
// No prescribed trajectories, delays, clamps, contacts, or fixed masses.
function derivatives(y, v, dy, dv) {
for (let i = 0; i < N; i++) {
dy[i] = v[i];
dv[i] = G;
}
for (let i = 0; i < N - 1; i++) {
const j = i + 1;
const force = K * (y[j] - y[i] - L0) + C * (v[j] - v[i]);
dv[i] += force / M;
dv[j] -= force / M;
}
}
function step(s, h) {
const { y, v, ty, tv, ky, kv } = s;
derivatives(y, v, ky[0], kv[0]);
for (let i = 0; i < N; i++) {
ty[i] = y[i] + 0.5 * h * ky[0][i];
tv[i] = v[i] + 0.5 * h * kv[0][i];
}
derivatives(ty, tv, ky[1], kv[1]);
for (let i = 0; i < N; i++) {
ty[i] = y[i] + 0.5 * h * ky[1][i];
tv[i] = v[i] + 0.5 * h * kv[1][i];
}
derivatives(ty, tv, ky[2], kv[2]);
for (let i = 0; i < N; i++) {
ty[i] = y[i] + h * ky[2][i];
tv[i] = v[i] + h * kv[2][i];
}
derivatives(ty, tv, ky[3], kv[3]);
for (let i = 0; i < N; i++) {
y[i] += h / 6 * (ky[0][i] + 2 * ky[1][i] +
2 * ky[2][i] + ky[3][i]);
v[i] += h / 6 * (kv[0][i] + 2 * kv[1][i] +
2 * kv[2][i] + kv[3][i]);
}
s.ticks++;
}
const canvas = document.getElementById("canvas");
const ctx = canvas.getContext("2d");
const releaseButton = document.getElementById("release");
const resetButton = document.getElementById("reset");
const speedSlider = document.getElementById("speed");
const speedValue = document.getElementById("speedValue");
const clock = document.getElementById("clock");
const topDrop = document.getElementById("topDrop");
const bottomDrop = document.getElementById("bottomDrop");
const comError = document.getElementById("comError");
const status = document.getElementById("status");
let state = makeState();
let released = false;
let markerY = null;
let speed = 1;
let accumulator = 0;
let previousTime = null;
let width = 800;
let height = 620;
let scale = 180;
const topMargin = 48;
function resize() {
const box = canvas.getBoundingClientRect();
width = box.width;
height = box.height;
const ratio = window.devicePixelRatio || 1;
canvas.width = Math.round(width * ratio);
canvas.height = Math.round(height * ratio);
ctx.setTransform(ratio, 0, 0, ratio, 0, 0);
// Fixed world framing, independent of time and current mass positions.
scale = (height - 115) / (hangingLength + 0.9);
draw();
}
function screenY(y) {
return topMargin + y * scale;
}
function dot(x, y, r, colour) {
ctx.beginPath();
ctx.arc(x, y, r, 0, 2 * Math.PI);
ctx.fillStyle = colour;
ctx.fill();
}
function draw() {
ctx.clearRect(0, 0, width, height);
const cx = width * 0.5;
const coilWidth = Math.min(33, width * 0.085);
// Metre ruler; neither this nor the marker follows the falling masses.
ctx.font = "12px system-ui, sans-serif";
ctx.textAlign = "left";
const rulerX = 24;
const visibleDepth = (height - topMargin) / scale;
for (let y = 0; y <= visibleDepth; y += 0.25) {
const py = screenY(y);
const major = Math.round(y * 4) % 2 === 0;
ctx.strokeStyle = major ? "#2b4058" : "#1c3045";
ctx.beginPath();
ctx.moveTo(rulerX, py);
ctx.lineTo(width - 16, py);
ctx.stroke();
if (major) {
ctx.fillStyle = "#8199b5";
ctx.fillText(y.toFixed(1) + " m", rulerX, py - 5);
}
}
if (markerY !== null) {
const py = screenY(markerY);
ctx.save();
ctx.setLineDash([8, 6]);
ctx.strokeStyle = "#ffd77f";
ctx.lineWidth = 1.5;
ctx.beginPath();
ctx.moveTo(14, py);
ctx.lineTo(width - 14, py);
ctx.stroke();
ctx.restore();
const label = "Bottom at release";
ctx.font = "12px system-ui, sans-serif";
const labelWidth = ctx.measureText(label).width;
ctx.fillStyle = "#101c2b";
ctx.fillRect(18, py - 23, labelWidth + 12, 20);
ctx.fillStyle = "#ffd77f";
ctx.fillText(label, 24, py - 9);
}
// The support remains drawn but exerts no force after release.
ctx.strokeStyle = "#d2e0ee";
ctx.lineWidth = 3;
ctx.beginPath();
ctx.moveTo(cx - 30, topMargin - 17);
ctx.lineTo(cx + 30, topMargin - 17);
ctx.stroke();
if (!released) {
ctx.lineWidth = 2;
ctx.beginPath();
ctx.moveTo(cx, topMargin - 17);
ctx.lineTo(cx, screenY(state.y[0]));
ctx.stroke();
}
// Each sinusoidal turn represents one spring between adjacent masses.
ctx.strokeStyle = "#9be2f3";
ctx.lineWidth = 2;
ctx.lineJoin = "round";
ctx.beginPath();
ctx.moveTo(cx, screenY(state.y[0]));
for (let i = 0; i < N - 1; i++) {
for (let j = 1; j <= 16; j++) {
const u = j / 16;
const x = cx + coilWidth * Math.sin(2 * Math.PI * u);
const y = state.y[i] + u * (state.y[i + 1] - state.y[i]);
ctx.lineTo(x, screenY(y));
}
}
ctx.stroke();
// All 64 mass locations are visible; endpoint colours are visual only.
for (let i = 0; i < N; i++) {
dot(cx, screenY(state.y[i]), 2.1, "#e8f8ff");
}
dot(cx, screenY(state.y[0]), 4, "#ffad91");
dot(cx, screenY(state.y[N - 1]), 4, "#ffd77f");
if (!released) {
ctx.textAlign = "center";
ctx.fillStyle = "#b9c9df";
ctx.font = "13px system-ui, sans-serif";
ctx.fillText("More weight below → more stretch",
cx, height - 24);
}
const t = state.ticks * DT;
clock.textContent = (1000 * t).toFixed(1);
topDrop.textContent = (1000 * (state.y[0] - hanging[0])).toFixed(2);
bottomDrop.textContent =
(1000 * (state.y[N - 1] - hanging[N - 1])).toFixed(2);
const error = mean(state.y) - initialCOM - 0.5 * G * t * t;
comError.textContent = (1000 * error).toFixed(3);
if (released) {
let entirelyBelow = true;
for (let i = 0; i < N; i++) {
if (screenY(state.y[i]) <= height) {
entirelyBelow = false;
break;
}
}
status.textContent = entirelyBelow
? "The slinky is below the fixed view. Physics and clock continue; Reset to repeat."
: "Released: all 64 masses are free. Gold line fixed at the release height.";
}
}
releaseButton.addEventListener("click", () => {
if (released) return;
markerY = state.y[N - 1];
released = true;
accumulator = 0;
previousTime = performance.now();
releaseButton.disabled = true;
draw();
});
resetButton.addEventListener("click", () => {
state = makeState();
released = false;
markerY = null;
accumulator = 0;
previousTime = performance.now();
releaseButton.disabled = false;
status.textContent = "Hanging in exact static equilibrium.";
draw();
});
function updateSpeed() {
speed = Math.pow(20, (Number(speedSlider.value) - 100) / 100);
speedValue.textContent = speed.toFixed(2) + "×";
speedSlider.setAttribute("aria-valuetext",
speed.toFixed(2) + " times full speed");
}
speedSlider.addEventListener("input", updateSpeed);
document.addEventListener("visibilitychange", () => {
// Do not accumulate wall-clock time while this exhibit is hidden.
previousTime = null;
});
window.addEventListener("resize", resize);
function frame(now) {
if (previousTime === null) previousTime = now;
const elapsed = (now - previousTime) / 1000;
previousTime = now;
if (released && !document.hidden) {
accumulator += elapsed * speed;
// Work budget only: retain any unprocessed time in the accumulator.
// No enlarged timesteps and no discarded physical evolution.
let budget = 800;
while (accumulator >= DT && budget > 0) {
step(state, DT);
accumulator -= DT;
budget--;
}
}
draw();
requestAnimationFrame(frame);
}
function numericalChecks() {
const coarse = makeState();
const fine = makeState();
const sampleTimes = [100, 200, 250, 300, 350, 400];
const tbody = document.getElementById("checks");
let onset = null;
let maxCOMError = 0;
for (const milliseconds of sampleTimes) {
const targetTick = Math.round(milliseconds / (1000 * DT));
while (coarse.ticks < targetTick) {
step(coarse, DT);
step(fine, DT / 2);
step(fine, DT / 2);
const t = coarse.ticks * DT;
if (onset === null &&
coarse.y[N - 1] - hanging[N - 1] >= 0.001) {
onset = t * 1000;
}
maxCOMError = Math.max(maxCOMError,
Math.abs(mean(coarse.y) - initialCOM - 0.5 * G * t * t));
}
let difference = 0;
for (let i = 0; i < N; i++) {
difference = Math.max(difference,
Math.abs(coarse.y[i] - fine.y[i]));
}
const row = document.createElement("tr");
const entries = [
milliseconds + " ms",
(1000 * (coarse.y[0] - hanging[0])).toFixed(3) + " mm",
(1000 * (coarse.y[N - 1] - hanging[N - 1])).toFixed(3) + " mm",
(1000 * difference).toExponential(2) + " mm"
];
for (const entry of entries) {
const cell = document.createElement("td");
cell.textContent = entry;
row.appendChild(cell);
}
tbody.appendChild(row);
}
// Verify the analytic hanging state independently through the force loop.
const dy = new Float64Array(N);
const acceleration = new Float64Array(N);
derivatives(hanging, new Float64Array(N), dy, acceleration);
let equilibriumResidual = 0;
for (let i = 1; i < N; i++) {
equilibriumResidual = Math.max(equilibriumResidual,
Math.abs(acceleration[i]));
}
document.getElementById("checkSummary").textContent =
"Computed first bottom drop of 1 mm: " +
(onset === null ? "not reached within 400 ms" : onset.toFixed(2) + " ms") +
". Maximum COM error through 400 ms: " +
(1000 * maxCOMError).toExponential(2) + " mm. " +
"Initial acceleration residual of the unsupported hanging masses: " +
equilibriumResidual.toExponential(2) + " m/s². " +
"Initial top acceleration immediately after release: " +
acceleration[0].toFixed(2) + " m/s².";
}
updateSpeed();
numericalChecks();
resize();
requestAnimationFrame(frame);
})();
</script>
</body>
</html>
What it actually shows
I have not executed this file in a browser, so I cannot honestly claim that I observed it reproduce the prediction. The timing and displacement estimates above remain predictions, not measured results.
The file exposes the test: live endpoint displacements, a fixed marker, and a computed table through 400 ms. It also compares two timesteps and checks centre-of-mass free fall. Those checks report numerical results without modifying the animation.
The important limitation is physical rather than hidden scripting: this models an elastic spring chain, not coil collisions and close-packed collapse. It is intended to reproduce the initial bottom-hovering phenomenon; it should not be presented as a faithful model of the later piled-up slinky.
Attachments
stealth/union-alpha — page