Run Detail
completedmuse-wonderRecorded 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
69.7s
Total Tokens
9,259
Input Tokens
737
Output Tokens
8,522
Reasoning Tokens
4,230
Reasoning Effort
default
Est. Cost
$0.1734
Started
10/12/2026, 5:58:50 PM
OR Provider
Meta
Finish Reason
stop
Generation ID
gen-1791827928-YvJm8JDRk8eXJJUH4nNX
Turns (1)
Turn #1
737 in8,522 out4,230 reasoning9,259 total69.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
In the first few hundred milliseconds after release the bottom end will remain essentially stationary at the marker line — moving by at most a few millimetres — for roughly $300\ \text{ms}$, while the top end rushes downward, initially accelerating at about $Ng$ (here $60g$, because the top coil initially feels gravity plus the downward pull of the spring below it carrying almost the whole slinky's weight); meanwhile the centre of mass, unlike either end, accelerates downward at exactly $g$ from $t=0$. This is required because each lower coil is initially in force balance — the upward tension in the spring above it exactly cancels its weight plus the downward pull of the spring below — and that balance cannot change until the collapse wave, travelling down as successive upper coils lose tension and contract to their natural length, reaches it; only when the collapsed coils pile onto the bottom, at about $0.3\ \text{s}$, does the bottom begin to fall, after which the whole compressed slinky drops together past the marker line.
The setup
- Model: $N = 60$ point masses in a vertical line, neighbours connected by Hookean springs, uniform gravity, small linear viscous damping. Every mass obeys the identical force law (gravity $+\ mg$ downward, spring forces $k,\Delta\ell$ from each neighbour, damping $-cv$); there is no per-segment scripting of any kind.
- Parameters: mass per segment $m = 0.008\ \text{kg}$ (total $0.48\ \text{kg}$); spring constant $k = 300\ \text{N/m}$ between neighbours; natural length per spring $\ell_0 = 0.003\ \text{m}$; damping $c = 0.001\ \text{N·s/m}$ per mass; $g = 9.81\ \text{m/s}^2$. Display scale $550\ \text{px/m}$.
- Hanging equilibrium (solved, not relaxed, not even-spaced): with the top mass held, the spring between masses $j-1$ and $j$ must support the weight of the $N-j$ masses below it, so its equilibrium extension is $(N-j)mg/k$. Positions are built cumulatively: $y_0$ at the support, $y_i = y_{i-1} + \ell_0 + (N-i)mg/k$. This gives wide spacing at the top ($\approx 15.4\ \text{mm}$ between the top coils) tapering to near-natural spacing at the bottom ($\approx 3.3\ \text{mm}$), total stretched length $\approx 0.64\ \text{m}$, and exactly zero net force on every mass except the held top one.
- Integrator: semi-implicit (symplectic) Euler — accelerations from Hooke's law, then $v \mathrel{+}= a,\Delta t$, then $y \mathrel{+}= v,\Delta t$ — at fixed $\Delta t = 10^{-4}\ \text{s}$. The stiffest mode has $\omega = \sqrt{k/m} \approx 194\ \text{rad/s}$, so $\omega\Delta t \approx 0.019 \ll 1$: comfortably stable with no velocity clamping or other fudge factors. At full speed this is $\sim$170 substeps per animation frame; the speed slider ($0.05\times$–$1\times$) only scales how much simulated time is advanced per frame, never the timestep.
- Release: the only change on Release is that the top mass stops being held. From that instant no mass is pinned, frozen, delayed, or treated differently from any other. The marker is placed at the bottom mass's height at that instant, and the clock starts.
The file
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="utf-8">
<meta name="viewport" content="width=device-width, initial-scale=1">
<title>Falling Slinky</title>
<style>
:root { color-scheme: dark; }
* { box-sizing: border-box; }
body {
margin: 0; padding: 16px;
font-family: system-ui, -apple-system, "Segoe UI", sans-serif;
background: #14171c; color: #e8ecf1;
display: flex; flex-direction: column; align-items: center; gap: 12px;
}
h1 { font-size: 20px; margin: 4px 0 0; font-weight: 600; }
p.sub { margin: 0; font-size: 13px; color: #9fb0c3; max-width: 960px; text-align: center; }
#wrap { width: min(960px, 100%); }
canvas {
display: block; width: 100%; height: auto;
background: #0b0e13; border: 1px solid #2c3644; border-radius: 8px;
}
#controls {
display: flex; flex-wrap: wrap; gap: 14px; align-items: center;
justify-content: center; margin-top: 12px;
background: #1b212b; border: 1px solid #2c3644; border-radius: 8px; padding: 12px 16px;
}
button {
font-size: 15px; padding: 8px 20px; border-radius: 6px; border: 1px solid #3d4c63;
background: #2a6fdb; color: #fff; cursor: pointer;
}
button#reset { background: #39445a; }
button:disabled { opacity: 0.45; cursor: default; }
label { font-size: 13px; color: #c6d2e0; display: flex; align-items: center; gap: 8px; }
input[type="range"] { width: 170px; }
#clock {
font-variant-numeric: tabular-nums; font-size: 22px; font-weight: 600;
background: #0b0e13; border: 1px solid #2c3644; border-radius: 6px; padding: 6px 14px;
min-width: 170px; text-align: center;
}
#readout { font-variant-numeric: tabular-nums; font-size: 13px; color: #9fb0c3; min-width: 230px; }
.val { color: #e8ecf1; font-weight: 600; }
</style>
</head>
<body>
<h1>The Falling Slinky</h1>
<p class="sub">60 masses joined by springs ($k = 300$ N/m, $m = 8$ g each), hung in true equilibrium —
coils stretched wide at the top, close at the bottom. Press Release and watch the bottom end against the marker line.</p>
<div id="wrap">
<canvas id="cv" width="960" height="720"></canvas>
<div id="controls">
<button id="release">Release</button>
<button id="reset">Reset</button>
<label>Speed
<input type="range" id="speed" min="0.05" max="1" step="0.05" value="1">
<span class="val" id="speedVal">1.00×</span>
</label>
<div id="clock">0.0 ms</div>
<div id="readout">bottom displacement from marker: <span class="val" id="disp">—</span></div>
</div>
</div>
<script>
"use strict";
// ---------- Physics parameters ----------
var N = 60; // number of masses (>= 40)
var M = 0.008; // kg per mass
var K = 300.0; // N/m, spring between neighbouring masses
var L0 = 0.003; // m, natural length of each spring
var C = 0.001; // N s/m, viscous damping per mass
var G = 9.81; // m/s^2
var DT = 0.0001; // s, fixed integration timestep (omega*DT ~ 0.019: stable)
// ---------- Display ----------
var SCALE = 550; // px per metre
var TOP_PX = 90; // px, height of the support / top mass at rest
var CX = 480; // px, horizontal centre of the slinky
var COIL_R = 85; // px, half-width of a drawn coil
var cv = document.getElementById('cv');
var ctx = cv.getContext('2d');
// ---------- State ----------
var y = new Float64Array(N); // positions, metres downward from canvas top (world coords)
var v = new Float64Array(N); // velocities, m/s downward
var a = new Float64Array(N); // accelerations
var mode = 'hanging'; // 'hanging' | 'falling'
var simTime = 0; // seconds since release
var markerY = null; // world y (m) of bottom at release, or null
function worldFromPx(px) { return px / SCALE; }
function equilibrium() {
// True hanging equilibrium with mass 0 held at the support.
// Spring j (between j-1 and j) carries the weight of the N-j masses at/below j,
// so its extension is (N-j)*M*G/K. Spacing therefore decreases downward.
y[0] = worldFromPx(TOP_PX);
for (var i = 1; i < N; i++) {
var extension = (N - i) * M * G / K;
y[i] = y[i - 1] + L0 + extension;
}
for (var j = 0; j < N; j++) v[j] = 0;
}
function computeAccelerations() {
var i;
for (i = 0; i < N; i++) a[i] = G - (C / M) * v[i];
for (i = 0; i < N - 1; i++) {
var ext = (y[i + 1] - y[i]) - L0; // >0 stretched, <0 compressed
var f = K * ext; // Hooke's law
a[i] += f / M; // spring pulls upper mass downward
a[i + 1] -= f / M; // spring pulls lower mass upward
}
}
function step(dt) {
// Semi-implicit (symplectic) Euler. Identical rule for every mass.
computeAccelerations();
for (var i = 0; i < N; i++) {
v[i] += a[i] * dt;
y[i] += v[i] * dt;
}
}
// ---------- Controls ----------
var releaseBtn = document.getElementById('release');
var resetBtn = document.getElementById('reset');
var speedInput = document.getElementById('speed');
var speedVal = document.getElementById('speedVal');
var clockEl = document.getElementById('clock');
var dispEl = document.getElementById('disp');
function doReset() {
mode = 'hanging';
simTime = 0;
markerY = null;
equilibrium();
releaseBtn.disabled = false;
clockEl.textContent = '0.0 ms';
dispEl.innerHTML = '—';
}
releaseBtn.addEventListener('click', function () {
if (mode !== 'hanging') return;
markerY = y[N - 1]; // marker at bottom's height at instant of release
simTime = 0;
mode = 'falling'; // from here on, nothing is held; all masses obey the same law
releaseBtn.disabled = true;
});
resetBtn.addEventListener('click', doReset);
speedInput.addEventListener('input', function () {
speedVal.textContent = Number(speedInput.value).toFixed(2) + '\u00d7';
});
// ---------- Drawing ----------
function px(metres) { return metres * SCALE; }
function draw() {
ctx.clearRect(0, 0, cv.width, cv.height);
// Marker line (stays where it was put at release)
if (markerY !== null) {
var my = px(markerY);
ctx.save();
ctx.strokeStyle = '#ff5252';
ctx.lineWidth = 2;
ctx.setLineDash([10, 7]);
ctx.beginPath(); ctx.moveTo(0, my); ctx.lineTo(cv.width, my); ctx.stroke();
ctx.setLineDash([]);
ctx.fillStyle = '#ff8a80';
ctx.font = '14px system-ui, sans-serif';
ctx.fillText('bottom at release', 14, my - 8);
ctx.restore();
}
// Support (only while hanging)
if (mode === 'hanging') {
ctx.strokeStyle = '#8fa3bd';
ctx.lineWidth = 3;
ctx.beginPath(); ctx.moveTo(CX - 110, TOP_PX - 22); ctx.lineTo(CX + 110, TOP_PX - 22); ctx.stroke();
ctx.lineWidth = 2;
ctx.beginPath(); ctx.moveTo(CX, TOP_PX - 22); ctx.lineTo(CX, px(y[0])); ctx.stroke();
for (var h = -100; h <= 100; h += 20) {
ctx.beginPath(); ctx.moveTo(CX + h, TOP_PX - 22); ctx.lineTo(CX + h - 8, TOP_PX - 34); ctx.stroke();
}
}
// Centre of mass marker (side tick) — falls at g from t=0
var com = 0;
for (var i = 0; i < N; i++) com += y[i];
com /= N;
ctx.fillStyle = '#ffd54f';
ctx.beginPath();
var cy = px(com);
ctx.moveTo(CX + COIL_R + 34, cy);
ctx.lineTo(CX + COIL_R + 48, cy - 6);
ctx.lineTo(CX + COIL_R + 48, cy + 6);
ctx.closePath(); ctx.fill();
ctx.font = '12px system-ui, sans-serif';
ctx.fillText('centre of mass', CX + COIL_R + 52, cy + 4);
// Connecting spine
ctx.strokeStyle = '#54657c';
ctx.lineWidth = 1.5;
ctx.beginPath();
ctx.moveTo(CX, px(y[0]));
for (var s = 1; s < N; s++) ctx.lineTo(CX, px(y[s]));
ctx.stroke();
// Coils: one horizontal bar per mass; top highlighted blue, bottom red
for (var j = 0; j < N; j++) {
var yy = px(y[j]);
if (j === 0) { ctx.strokeStyle = '#64b5f6'; ctx.lineWidth = 4; }
else if (j === N-1) { ctx.strokeStyle = '#ff5252'; ctx.lineWidth = 4; }
else {
var t = j / (N - 1);
ctx.strokeStyle = 'rgb(' + Math.round(120 + 60 * t) + ',' + Math.round(180 - 40 * t) + ',220)';
ctx.lineWidth = 2.5;
}
ctx.beginPath();
ctx.moveTo(CX - COIL_R, yy);
ctx.lineTo(CX + COIL_R, yy);
ctx.stroke();
ctx.fillStyle = ctx.strokeStyle;
ctx.beginPath(); ctx.arc(CX, yy, 3, 0, Math.PI * 2); ctx.fill();
}
// Labels for the ends
ctx.font = '13px system-ui, sans-serif';
ctx.fillStyle = '#64b5f6';
ctx.fillText('top', CX - COIL_R - 34, px(y[0]) + 4);
ctx.fillStyle = '#ff8a80';
ctx.fillText('bottom', CX - COIL_R - 58, px(y[N - 1]) + 4);
}
// ---------- Main loop ----------
var lastTs = null;
var accumulator = 0;
function frame(ts) {
if (lastTs === null) lastTs = ts;
var realDt = (ts - lastTs) / 1000;
lastTs = ts;
if (realDt > 0.05) realDt = 0.05; // avoid a huge catch-up after a stalled frame
if (mode === 'falling') {
var speed = Number(speedInput.value);
accumulator += realDt * speed;
var steps = Math.floor(accumulator / DT);
if (steps > 5000) steps = 5000; // safety cap; DT itself is never changed
for (var s = 0; s < steps; s++) step(DT);
accumulator -= steps * DT;
simTime += steps * DT;
clockEl.textContent = (simTime * 1000).toFixed(1) + ' ms';
var dispMm = (y[N - 1] - markerY) * 1000;
dispEl.textContent = (dispMm >= 0 ? '+' : '') + dispMm.toFixed(1) + ' mm';
}
draw();
requestAnimationFrame(frame);
}
doReset();
requestAnimationFrame(frame);
</script>
</body>
</html>
What it actually shows
Honestly: I cannot run this file in this environment, so I have not observed it, and I will not claim I have. What I can say is what the construction guarantees and where it might let you down. The initial condition is the analytic equilibrium, so at the instant of release every mass except the top has exactly zero net force in exact arithmetic — the bottom's stillness is not tuned in, and if the code is correct it should hold the marker to well under a millimetre until the collapse wave arrives, then fall. The top's initial acceleration of $60g$ and the $\sim 0.3\ \text{s}$ collapse time are estimates from the parameters, not measurements; the actual collapse time in the simulation could plausibly be $0.25$–$0.35\ \text{s}$, and I am unsure of it to better than that. Two known weaknesses to watch for when you test it: first, the discrete chain carries the collapse as a wave through 60 springs, so the bottom may creep by a fraction of a millimetre early on rather than being perfectly frozen as a continuum slinky's would be — the on-screen displacement readout will show this if it happens; second, after collapse the coils interact only through the same Hookean springs in compression, not through inelastic coil-on-coil contact, so the fallen slinky may bounce or re-expand slightly in a way a real slinky, whose coils clack together and stay, would not. The integrator itself should not explode at any slider setting, since the slider changes only how many fixed $10^{-4}\ \text{s}$ steps are taken per frame, never the step size — but if you see the bottom drift centimetres before $\sim 250\ \text{ms}$, or the top hesitate, then the simulation disagrees with the prediction above and the prediction is what the physics demands, so the code would be wrong.
Attachments
meta/muse-wonder — page