Run Detail
completedgrok-4.7Recorded 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
689.9s
Total Tokens
50,692
Input Tokens
1,971
Output Tokens
48,721
Reasoning Tokens
43,229
Reasoning Effort
default
Cached Input Tokens
1,152
Est. Cost
$0.2356
Started
9/22/2026, 4:53:33 AM
OR Provider
xAI
Finish Reason
stop
Generation ID
gen-1790052813-PRY1ubMnC9d29AumG9Dp
Turns (1)
Turn #1
1,971 in48,721 out43,229 reasoning1,152 cached50,692 total689.9s
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 mass moves in the first step and the bottom mass does not. At release the spring under the top is still carrying the weight of the other 49 masses, so the top is yanked downward at an initial acceleration of (N g = 490.5,\mathrm{m/s^2}), and the collapse runs from the top down. Every lower mass is sitting in exact force balance, and that balance depends only on its neighbours’ positions, so it cannot start moving until the motion above it arrives. The centre of mass falls at (g) the whole time (link forces cancel in pairs) and starts about (0.54,\mathrm{m}) above the bottom; a slinky collapsed onto the unmoving bottom only becomes possible once that gap has been closed, which is about (320,\mathrm{ms}). Against the marker I therefore expect the bottom still on the line at (200,\mathrm{ms}), the hook empty and the upper coils bunched well below it, and the bottom leaving the line near (320,\mathrm{ms}) — by (400,\mathrm{ms}) at the latest — after which the whole chain falls through the line together.
The setup
Fifty masses, (m = 0.01,\mathrm{kg}), coupled by Hookean springs (k = 80,\mathrm{N/m}) with rest length (L_0 = 0.001,\mathrm{m}). Gravity (g = 9.81,\mathrm{m/s^2}). Damping is internal and viscous, (c = 0.02,\mathrm{N\cdot s/m}) on each link’s relative velocity, so it does not drag the centre of mass. Integrator is semi-implicit Euler with (\Delta t = 50,\mu\mathrm{s}): all forces from the current state, then (v \leftarrow v + (F/m)\Delta t), then (y \leftarrow y + v\Delta t), same update for every mass. No velocity clamp. If a speed exceeds (10^4,\mathrm{m/s}) the loop halts and says so.
The hang is the closed-form static solution, not even spacing and not a relaxed leftover. With (y) downward, the spring whose lower end is mass (i) ((i = 1\ldots 49)) has stretch ((N-i),mg/k). That is (60.1,\mathrm{mm}) on the top link and (1.23,\mathrm{mm}) on the bottom link, plus (L_0). Held mass at (y_0 = 0.20,\mathrm{m}); hanging length below it (1.551,\mathrm{m}); centre of mass (1.016,\mathrm{m}) below the held mass. While it is held, mass 0 is a constraint, not a force-law exception. After Release that constraint is gone: netForce has no hold flag, no delay, and no index special case beyond “a free end has one neighbour.” The helix is a drawing of those vertical positions; transverse motion is not in the model. The clock is integrated simulation time, so it reads the same at (1\times) and at (1/20). The marker is the equilibrium bottom coordinate and is not updated again.
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 {
--ink: #f3ead7;
--muted: #b5a48f;
--wall: #241c17;
--brass: #c4a574;
--red: #e23b2b;
}
* { box-sizing: border-box; }
html, body { margin: 0; padding: 0; }
body {
min-height: 100vh;
background:
radial-gradient(ellipse 90% 40% at 50% -10%, #4a382c 0%, transparent 50%),
var(--wall);
color: var(--ink);
font-family: Palatino, "Palatino Linotype", "Book Antiqua", Georgia, serif;
}
.wrap {
max-width: 760px;
margin: 0 auto;
padding: 28px 18px 48px;
}
header { border-left: 4px solid var(--red); padding: 0 0 4px 16px; }
.eyebrow {
margin: 0;
font-size: 12px;
letter-spacing: 0.22em;
text-transform: uppercase;
color: var(--brass);
}
h1 {
margin: 4px 0 8px;
font-weight: 500;
font-size: 34px;
letter-spacing: 0.01em;
}
.lede { margin: 0; max-width: 62ch; color: var(--muted); font-size: 17px; line-height: 1.45; }
.frame {
margin-top: 18px;
background: #120e0c;
border: 1px solid #6a513c;
padding: 10px;
box-shadow: 0 16px 40px rgba(0, 0, 0, 0.35);
}
canvas {
width: 100%;
height: auto;
aspect-ratio: 640 / 760;
display: block;
background: #0e0c0a;
}
.readout {
display: flex;
justify-content: space-between;
align-items: flex-end;
gap: 12px;
padding: 10px 4px 0;
}
.clock {
font-family: ui-monospace, "SF Mono", Menlo, Consolas, monospace;
font-variant-numeric: tabular-nums;
font-size: 40px;
letter-spacing: 0.03em;
line-height: 1;
}
.clock small {
display: block;
margin-top: 4px;
font-family: Palatino, Georgia, serif;
font-size: 13px;
letter-spacing: 0.04em;
color: var(--muted);
}
.delta {
font-family: ui-monospace, "SF Mono", Menlo, Consolas, monospace;
font-size: 14px;
color: var(--brass);
text-align: right;
line-height: 1.4;
}
.controls {
display: flex;
flex-wrap: wrap;
align-items: center;
gap: 12px 18px;
margin-top: 14px;
}
button {
font-family: inherit;
font-size: 16px;
letter-spacing: 0.14em;
text-transform: uppercase;
color: #1a120c;
background: linear-gradient(#e6c79a, #b8884e);
border: 1px solid #f0ddb8;
padding: 11px 20px;
cursor: pointer;
}
button:disabled { opacity: 0.38; cursor: default; }
button:focus-visible, input:focus-visible {
outline: 2px solid var(--brass);
outline-offset: 3px;
}
.speed {
display: flex;
align-items: center;
gap: 10px;
color: var(--muted);
font-size: 15px;
}
input[type="range"] { width: 160px; accent-color: #d4894a; }
#speedval {
font-family: ui-monospace, Menlo, Consolas, monospace;
color: var(--ink);
min-width: 5.5em;
}
.fine {
margin: 16px 0 0;
color: #8d7d6b;
font-size: 13px;
line-height: 1.45;
max-width: 70ch;
}
</style>
</head>
<body>
<main class="wrap">
<header>
<p class="eyebrow">Mechanics · a free chain</p>
<h1>The falling slinky</h1>
<p class="lede">Release the top. The red line is the bottom at that moment, and it is not moved again. The clock is simulation time, so a slow slider does not change what it reads.</p>
</header>
<div class="frame">
<canvas id="view" width="640" height="760"></canvas>
</div>
<div class="readout">
<div class="clock" id="clock">0 ms<small>simulation time since release</small></div>
<div class="delta" id="delta">hanging</div>
</div>
<div class="controls">
<button type="button" id="release">Release</button>
<button type="button" id="reset">Reset</button>
<label class="speed">Speed
<input id="speed" type="range" min="0.05" max="1" value="1" step="0.01">
<span id="speedval">1×</span>
</label>
</div>
<p class="fine">50 masses of 10 g, k = 80 N/m, rest length 1 mm, link damping 0.02 N·s/m, g = 9.81. Semi-implicit Euler, Δt = 50 µs. The hang is the exact static stretch — the link above mass i carries (N − i)mg/k — not even spacing. After release every mass uses the same force law. The helix is only a drawing of the vertical positions; this model has no transverse degrees of freedom. A speed past 10⁴ m/s stops the loop and is not clamped.</p>
</main>
<script>
"use strict";
const N = 50;
const m = 0.01;
const k = 80;
const L0 = 0.001;
const g = 9.81;
const c = 0.02;
const dt = 0.00005;
const Y_TOP = 0.2;
const VIEW_TOP = 0;
const VIEW_BOTTOM = 3.6;
const y = new Float64Array(N);
const v = new Float64Array(N);
const a = new Float64Array(N);
let held = true;
let failed = false;
let elapsed = 0;
let accum = 0;
let markerY = 0;
const canvas = document.getElementById("view");
const ctx = canvas.getContext("2d");
const clockEl = document.getElementById("clock");
const deltaEl = document.getElementById("delta");
const releaseBtn = document.getElementById("release");
const speedEl = document.getElementById("speed");
const speedVal = document.getElementById("speedval");
function hang() {
held = true;
failed = false;
elapsed = 0;
accum = 0;
y[0] = Y_TOP;
v[0] = 0;
for (let i = 1; i < N; i++) {
const stretch = (N - i) * m * g / k;
y[i] = y[i - 1] + L0 + stretch;
v[i] = 0;
}
markerY = y[N - 1];
}
function netForce(i) {
let F = m * g;
if (i > 0) {
const stretch = y[i] - y[i - 1] - L0;
F -= k * stretch + c * (v[i] - v[i - 1]);
}
if (i < N - 1) {
const stretch = y[i + 1] - y[i] - L0;
F += k * stretch + c * (v[i + 1] - v[i]);
}
return F;
}
function step() {
for (let i = 0; i < N; i++) a[i] = netForce(i) / m;
for (let i = 0; i < N; i++) {
v[i] += a[i] * dt;
y[i] += v[i] * dt;
if (!Number.isFinite(y[i]) || Math.abs(v[i]) > 1e4) failed = true;
}
}
function equilibriumResidual() {
let maxA = 0;
for (let i = 1; i < N; i++) {
const ai = Math.abs(netForce(i) / m);
if (ai > maxA) maxA = ai;
}
return maxA;
}
let bitmapW = 0;
let bitmapH = 0;
function fit() {
const dpr = Math.min(window.devicePixelRatio || 1, 2);
const w = canvas.clientWidth;
const h = canvas.clientHeight;
if (w < 2 || h < 2) return false;
const bw = Math.round(w * dpr);
const bh = Math.round(h * dpr);
if (bw !== bitmapW || bh !== bitmapH) {
canvas.width = bw;
canvas.height = bh;
bitmapW = bw;
bitmapH = bh;
}
ctx.setTransform(dpr, 0, 0, dpr, 0, 0);
return true;
}
function yPx(ym, H) {
return (ym - VIEW_TOP) / (VIEW_BOTTOM - VIEW_TOP) * H;
}
const pieces = [];
function draw() {
if (!fit()) return;
const W = canvas.clientWidth;
const H = canvas.clientHeight;
ctx.clearRect(0, 0, W, H);
const bg = ctx.createRadialGradient(W * 0.5, H * 0.22, 20, W * 0.5, H * 0.38, H * 0.72);
bg.addColorStop(0, "#3c2e25");
bg.addColorStop(0.5, "#1a1411");
bg.addColorStop(1, "#0c0a09");
ctx.fillStyle = bg;
ctx.fillRect(0, 0, W, H);
ctx.fillStyle = "#3b2e24";
ctx.fillRect(0, 0, W, 26);
ctx.fillStyle = "#6b5340";
ctx.fillRect(0, 26, W, 6);
const cx = W * 0.5;
const R = Math.min(62, W * 0.1);
const hookEnd = yPx(held ? y[0] : Y_TOP, H);
ctx.strokeStyle = "#c4a574";
ctx.lineWidth = 3;
ctx.lineCap = "round";
ctx.beginPath();
ctx.moveTo(cx, 32);
ctx.lineTo(cx, hookEnd - 10);
ctx.stroke();
ctx.fillStyle = "#c4a574";
if (held) {
ctx.fillRect(cx - 16, hookEnd - 10, 32, 5);
ctx.fillRect(cx - 16, hookEnd - 10, 4, 14);
ctx.fillRect(cx + 12, hookEnd - 10, 4, 14);
} else {
ctx.save();
ctx.translate(cx, hookEnd - 8);
ctx.rotate(-0.5);
ctx.fillRect(-18, -2, 16, 4);
ctx.restore();
ctx.save();
ctx.translate(cx, hookEnd - 8);
ctx.rotate(0.5);
ctx.fillRect(2, -2, 16, 4);
ctx.restore();
}
const turns = 3;
const samples = 16;
pieces.length = 0;
for (let i = 0; i < N - 1; i++) {
const yA = y[i];
const yB = y[i + 1];
for (let j = 0; j < samples; j++) {
const t0 = j / samples;
const t1 = (j + 1) / samples;
const ang0 = (i + t0) * turns * Math.PI * 2;
const ang1 = (i + t1) * turns * Math.PI * 2;
pieces.push({
x0: cx + Math.sin(ang0) * R,
x1: cx + Math.sin(ang1) * R,
py0: yPx(yA + (yB - yA) * t0, H),
py1: yPx(yA + (yB - yA) * t1, H),
z: 0.5 * (Math.cos(ang0) + Math.cos(ang1))
});
}
}
pieces.sort(function (p, q) { return p.z - q.z; });
ctx.lineCap = "round";
for (let s = 0; s < pieces.length; s++) {
const seg = pieces[s];
const t = (seg.z + 1) * 0.5;
const r = t < 0.5 ? 62 + 88 * (t / 0.5) : 150 + 86 * ((t - 0.5) / 0.5);
const gc = t < 0.5 ? 34 + 50 * (t / 0.5) : 84 + 86 * ((t - 0.5) / 0.5);
const b = t < 0.5 ? 22 + 20 * (t / 0.5) : 42 + 62 * ((t - 0.5) / 0.5);
ctx.strokeStyle = "rgb(" + (r | 0) + "," + (gc | 0) + "," + (b | 0) + ")";
ctx.lineWidth = 1.15 + 2.3 * t;
ctx.beginPath();
ctx.moveTo(seg.x0, seg.py0);
ctx.lineTo(seg.x1, seg.py1);
ctx.stroke();
}
for (let i = 0; i < N; i++) {
const py = yPx(y[i], H);
ctx.beginPath();
ctx.arc(cx, py, 3.1, 0, Math.PI * 2);
ctx.fillStyle = "#1a120e";
ctx.fill();
ctx.beginPath();
ctx.arc(cx, py, 2.0, 0, Math.PI * 2);
ctx.fillStyle = "#ffe7c2";
ctx.fill();
}
let sum = 0;
for (let i = 0; i < N; i++) sum += y[i];
const cmy = yPx(sum / N, H);
ctx.strokeStyle = "#8fb4c4";
ctx.lineWidth = 1.5;
ctx.beginPath();
ctx.moveTo(cx + R + 16, cmy);
ctx.lineTo(cx + R + 36, cmy);
ctx.stroke();
ctx.fillStyle = "#8fb4c4";
ctx.font = "13px Palatino, Georgia, serif";
ctx.fillText("CM", cx + R + 40, cmy + 4);
const my = yPx(markerY, H);
ctx.strokeStyle = "#e23b2b";
ctx.lineWidth = 1.5;
ctx.beginPath();
ctx.moveTo(16, my);
ctx.lineTo(W - 16, my);
ctx.stroke();
ctx.fillStyle = "#e23b2b";
ctx.beginPath();
ctx.arc(16, my, 3.5, 0, Math.PI * 2);
ctx.fill();
ctx.beginPath();
ctx.arc(W - 16, my, 3.5, 0, Math.PI * 2);
ctx.fill();
ctx.font = "14px Palatino, Georgia, serif";
ctx.fillText("bottom at release", 26, my - 8);
if (failed) {
ctx.fillStyle = "#f3ead7";
ctx.font = "18px Palatino, Georgia, serif";
ctx.fillText("Integrator diverged. State was not clamped.", 20, H - 22);
}
}
function speedText() {
const s = parseFloat(speedEl.value);
if (s >= 0.995) return "1×";
if (s <= 0.052) return "1/20×";
return s.toFixed(2) + "×";
}
function updateReadout() {
const ms = Math.round(elapsed * 1000);
clockEl.firstChild.nodeValue = ms + " ms";
if (held) {
deltaEl.textContent = "equilibrium residual " + equilibriumResidual().toExponential(1) + " m/s²";
} else {
const dmm = (y[N - 1] - markerY) * 1000;
const sign = dmm >= 0 ? "+" : "";
deltaEl.textContent = "bottom " + sign + dmm.toFixed(2) + " mm (down +)";
}
}
releaseBtn.addEventListener("click", function () {
if (!held || failed) return;
markerY = y[N - 1];
held = false;
elapsed = 0;
accum = 0;
releaseBtn.disabled = true;
});
document.getElementById("reset").addEventListener("click", function () {
hang();
releaseBtn.disabled = false;
updateReadout();
});
speedEl.addEventListener("input", function () {
speedVal.textContent = speedText();
});
hang();
speedVal.textContent = speedText();
updateReadout();
let last = performance.now();
function frame(now) {
let wall = (now - last) / 1000;
last = now;
if (wall > 0.05) wall = 0.05;
if (!held && !failed) {
accum += wall * parseFloat(speedEl.value);
let n = 0;
while (accum >= dt && n < 4000 && !failed) {
step();
accum -= dt;
elapsed += dt;
n++;
}
if (n >= 4000) accum = 0;
}
draw();
updateReadout();
requestAnimationFrame(frame);
}
requestAnimationFrame(frame);
</script>
</body>
</html>
What it actually shows
I have not run the file. I will not say the bottom stays on the line because the force law says it should — that is the prediction, and it is untested until you press Release.
What I can certify from the source is only the setup: the hang is the static stretch (top link about 61 mm, bottom link about 2.2 mm), the residual readout should be roundoff and not a tenth of a metre per second squared, and after Release there is no per-mass delay in the integrator. What I cannot certify is the observation you are about to make. I do not know the millisecond at which the bottom readout leaves +0.00 mm. I do not know whether masses pass through one another — Hooke's law allows it, and I added no contact force. If the bottom is still on the line at 200 ms and leaves near 320 ms, the prediction holds. If it leaves immediately, or the residual is large while it is still hanging, the model is wrong and the prediction fails. The millimetre readout is the result; this paragraph is not.
Attachments
x-ai/grok-4.7 — page