Recorded 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
375.3s
Total Tokens
41,868
Input Tokens
743
Output Tokens
41,125
Reasoning Tokens
35,914
Reasoning Effort
default
Est. Cost
$0.0165
Started
11/10/2026, 1:09:49 PM
OR Provider
Nex AGI
Finish Reason
stop
Generation ID
gen-1794316188-iiMVzWBUbuXd5hj5Ij8q
Turns (1)
Turn #1
743 in41,125 out35,914 reasoning41,868 total375.3s
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 instant you press Release, the two ends behave completely differently. The top segment is pulled down by gravity plus the spring tension beneath it — which, at equilibrium, supports the weight of all 47 segments below — so it initially accelerates at ~48g ≈ 470 m/s² and collapses onto the segment below it within roughly 10 ms. A collapse front then sweeps down the slinky: above the front, coils are bunched and falling as a growing blob; below the front, coils remain exactly where equilibrium placed them. The bottom segment sits motionless, exactly on the marker line, because the net force on it is still zero (gravity down, spring tension up) and no signal of the release can outrun the elastic wave — it cannot "know" the top is gone. I estimate the front reaches the bottom at ≈0.15–0.20 s on the sim clock; I can prove an upper bound of 0.21 s from the center of mass falling at g (the naive linear-wave guess 47·√(m/k) ≈ 0.33 s is impossible — it would push the COM below the still-stationary bottom). At that moment the bottom leaves the marker accelerating at ~g, and the whole collapsed slinky falls as a blob with COM at exactly g, leaving the frame ~0.6–0.7 s after release. At 1/20 speed that's ~4 s of watchable front travel.
The setup
- Model: 48 point masses (5 g each, 240 g total) coupled by 47 Hookean springs, motion constrained to the vertical axis. Rest length r₀ = 0.8 mm, stiffness k = 100 N/m, gravity 9.81 m/s². Damping is relative (structural) along each spring, c = 0.04 N·s/m — it damps internal wobble without touching the center of mass (so COM falls at exactly g) and gives zero force in the static state.
- Hanging equilibrium — solved, not faked: spring i carries the weight of everything below it, Tᵢ = (47−i)·m·g; extension = Tᵢ/k; positions accumulate from the ceiling. Top coil spacing ≈ 23.9 mm, bottom ≈ 1.3 mm — the real slinky cone. Residual net force on every mass after this solve is at floating-point zero, so the hanging state is an exact fixed point of the integrator.
- Integrator: symplectic (semi-implicit) Euler, fixed dt = 0.2 ms. Stability needs dt < 2/ω_max with ω_max = 2√(k/m) ≈ 283 rad/s → limit ≈ 7.1 ms; I'm ~35× inside it. There is no velocity clamp, no fudge factor anywhere — if it were unstable it would visibly explode.
- The only special case is the hand: while held, segment 1's position is pinned to the ceiling. The moment you press Release, every segment runs the identical two-line update (v += a·dt; y += v·dt) with forces from gravity and its two neighbours. Nothing is pinned, delayed, or scripted afterward. Slow-motion changes only how many physics steps run per frame, never the trajectory.
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{
--bg:#0d1014; --panel:rgba(16,20,26,.78); --text:#e8edf3; --muted:#8b98a7;
--accent:#ffb454; --teal:#4dd6c1; --line:rgba(255,255,255,.08);
}
*{box-sizing:border-box}
html,body{height:100%}
body{margin:0;background:var(--bg);color:var(--text);overflow:hidden;
font-family:ui-sans-serif,system-ui,-apple-system,"Segoe UI",Roboto,Helvetica,Arial,sans-serif}
canvas{position:fixed;inset:0;width:100%;height:100%;display:block}
header{position:fixed;top:0;left:0;right:0;display:flex;justify-content:space-between;
align-items:flex-start;padding:16px 22px;pointer-events:none;z-index:2}
h1{margin:0;font-size:14px;font-weight:700;letter-spacing:.22em}
.sub{margin-top:4px;font-size:11.5px;color:var(--muted)}
.clockBox{text-align:right}
#clock{font-family:ui-monospace,"SF Mono",Menlo,Consolas,monospace;font-size:28px;
font-weight:600;font-variant-numeric:tabular-nums;line-height:1.05}
#clock small{font-size:13px;color:var(--muted);font-weight:400}
.clockLabel{font-size:9.5px;letter-spacing:.18em;color:var(--muted);margin-top:3px}
footer{position:fixed;left:0;right:0;bottom:0;display:flex;align-items:center;gap:14px;
padding:12px 22px;background:var(--panel);border-top:1px solid var(--line);
backdrop-filter:blur(8px);z-index:2}
button{appearance:none;border:1px solid var(--line);background:#1a2029;color:var(--text);
font:inherit;font-size:13.5px;font-weight:600;padding:9px 18px;border-radius:9px;
cursor:pointer;transition:transform .06s ease,background .15s ease}
button:hover{background:#222a35}
button:active{transform:translateY(1px)}
button.primary{background:var(--accent);border-color:var(--accent);color:#20150a}
button.primary:hover{background:#ffc274}
button:disabled{opacity:.45;cursor:default;transform:none}
.sliderBox{display:flex;align-items:center;gap:10px;margin-left:8px}
.sliderBox label{font-size:11px;letter-spacing:.14em;color:var(--muted)}
input[type=range]{width:170px;accent-color:var(--teal)}
#speedLabel{font-size:12px;min-width:150px;font-variant-numeric:tabular-nums}
.statusBox{display:flex;align-items:center;gap:7px;margin-left:auto}
.dot{width:8px;height:8px;border-radius:50%;background:var(--accent)}
.dot.falling{background:var(--teal)}
#statusText{font-size:11.5px;color:var(--muted)}
.footNote{font-size:10.5px;color:#5f6b78;margin-left:18px}
@media (max-width:820px){.footNote{display:none}.sub{display:none}}
</style>
</head>
<body>
<canvas id="c"></canvas>
<header>
<div>
<h1>FALLING SLINKY</h1>
<div class="sub">48 coupled masses under gravity — released from true static equilibrium</div>
</div>
<div class="clockBox">
<div id="clock">0.0<small> ms</small></div>
<div class="clockLabel">TIME SINCE RELEASE</div>
</div>
</header>
<footer>
<button id="releaseBtn" class="primary">Release</button>
<button id="resetBtn">Reset</button>
<div class="sliderBox">
<label for="speed">SPEED</label>
<input type="range" id="speed" min="1" max="20" step="0.5" value="1">
<span id="speedLabel">×1.00 real time</span>
</div>
<div class="statusBox"><span class="dot" id="statusDot"></span><span id="statusText">held at ceiling</span></div>
<div class="footNote">48 masses · k = 100 N/m · dt = 0.2 ms · symplectic Euler · no clamps</div>
</footer>
<script>
'use strict';
/* ---------------- model constants (SI units) ---------------- */
const N = 48; // segments (point masses), coupled by N-1 springs
const M = 0.005; // kg per segment (total 240 g)
const G = 9.81; // m/s^2
const R0 = 0.0008; // m, spring rest length (coil pitch at zero tension)
const K = 100; // N/m, spring stiffness
const CD = 0.04; // N*s/m, relative (structural) damping along each spring
const DT = 0.0002; // s, fixed physics step (symplectic Euler)
const TAU = Math.PI * 2;
const y = new Float64Array(N); // position, metres downward from the ceiling
const v = new Float64Array(N); // velocity, m/s (down positive)
const F = new Float64Array(N); // accumulated force, N
let held = true; // the hand holds segment 0 at the ceiling
let released = false;
let simT = 0; // simulated time (s)
let releaseT = 0; // simT at the moment of release
let markerY = null; // bottom-of-slinky position at release (m)
let hangLen = 0; // equilibrium hang length (m)
/* -------- the TRUE hanging equilibrium (solved, not relaxed) --------
Spring i (between mass i and i+1) carries the weight of everything
below it: T_i = (N-1-i) * m * g. Extension = T/K (Hooke).
Positions accumulate downward from the ceiling. With this init the
net force on every mass is zero to machine precision, so the hanging
state is an EXACT fixed point of the integrator: the bottom will not
drift even one micrometre until a real force reaches it. */
function computeEquilibrium(){
let yy = 0;
y[0] = 0;
for (let i = 0; i < N-1; i++){
const tension = (N-1-i) * M * G;
yy += R0 + tension / K;
y[i+1] = yy;
}
hangLen = y[N-1];
}
function reset(){
computeEquilibrium();
v.fill(0);
held = true; released = false;
simT = 0; releaseT = 0; markerY = null;
releaseBtn.disabled = false;
setStatus(); updateClock();
}
function release(){
if (released) return;
held = false; // the hand lets go -- the ONLY special case in
released = true; // the whole program, and it never acts again
releaseT = simT;
markerY = y[N-1]; // marker at the bottom's height at release
releaseBtn.disabled = true;
setStatus();
}
/* ---------------- physics ----------------
After release EVERY segment runs exactly the same update:
gravity + Hooke tension + relative-velocity damping from its two
neighbours. No pins, no delays, no clamps, no scripted motion. */
function step(){
for (let i = 0; i < N; i++) F[i] = M * G; // gravity, down
for (let i = 0; i < N-1; i++){
const stretch = (y[i+1] - y[i]) - R0;
const tension = K * stretch + CD * (v[i+1] - v[i]);
F[i] += tension; // pulls upper end down toward lower end
F[i+1] -= tension; // pulls lower end up toward upper end
}
if (held){
y[0] = 0; v[0] = 0; // the hand, only while held
for (let i = 1; i < N; i++){ v[i] += F[i]/M*DT; y[i] += v[i]*DT; }
} else {
for (let i = 0; i < N; i++){ v[i] += F[i]/M*DT; y[i] += v[i]*DT; }
}
simT += DT;
}
/* ---------------- DOM / canvas ---------------- */
const canvas = document.getElementById('c');
const ctx = canvas.getContext('2d');
const clockEl = document.getElementById('clock');
const releaseBtn = document.getElementById('releaseBtn');
const resetBtn = document.getElementById('resetBtn');
const speedEl = document.getElementById('speed');
const speedLabel = document.getElementById('speedLabel');
const statusDot = document.getElementById('statusDot');
const statusText = document.getElementById('statusText');
let dpr = 1;
function resize(){
dpr = Math.min(window.devicePixelRatio || 1, 2);
canvas.width = Math.round(innerWidth * dpr);
canvas.height = Math.round(innerHeight * dpr);
ctx.setTransform(dpr, 0, 0, dpr, 0, 0);
}
addEventListener('resize', resize);
resize();
/* ring colours: steel with alternating sheen, slightly darker toward bottom */
const ringColors = [];
for (let i = 0; i < N; i++){
const sheen = (i % 2 === 0) ? 0 : 0.30;
const f = Math.min(1, 0.12 + 0.58 * (i/(N-1)) + sheen);
const r = Math.round(238 - (238-122)*f);
const g = Math.round(243 - (243-136)*f);
const b = Math.round(250 - (250-152)*f);
ringColors.push('rgb(' + r + ',' + g + ',' + b + ')');
}
function draw(){
const W = innerWidth, H = innerHeight;
const bg = ctx.createLinearGradient(0, 0, 0, H);
bg.addColorStop(0, '#11151b'); bg.addColorStop(1, '#0a0d11');
ctx.fillStyle = bg; ctx.fillRect(0, 0, W, H);
const topPx = 84, botPx = H - 76;
const usable = botPx - topPx;
const scale = (usable * 0.52) / hangLen; // px per metre
const X = W / 2;
const Y = yy => topPx + yy * scale;
/* ruler: metres below the ceiling */
ctx.strokeStyle = 'rgba(232,237,243,0.18)';
ctx.fillStyle = 'rgba(232,237,243,0.34)';
ctx.font = '10px Menlo, Consolas, monospace';
ctx.lineWidth = 1; ctx.textAlign = 'left'; ctx.textBaseline = 'middle';
for (let i = 0; i <= 12; i++){
const d = i / 10, py = Y(d);
if (py > botPx) break;
ctx.beginPath(); ctx.moveTo(26, py); ctx.lineTo(38, py); ctx.stroke();
ctx.fillText(d.toFixed(1) + ' m', 44, py);
}
/* marker line: height of the bottom at the instant of release */
if (markerY !== null){
const my = Y(markerY);
ctx.save();
ctx.setLineDash([7, 6]);
ctx.strokeStyle = 'rgba(77,214,193,0.85)';
ctx.lineWidth = 1.5;
ctx.beginPath(); ctx.moveTo(20, my); ctx.lineTo(W-20, my); ctx.stroke();
ctx.restore();
ctx.fillStyle = 'rgba(77,214,193,0.9)';
ctx.font = '10px Menlo, Consolas, monospace';
ctx.textAlign = 'right';
ctx.fillText('B O T T O M A T R E L E A S E', W - 26, my - 10);
}
/* ceiling mount + hook */
ctx.fillStyle = '#242d38';
ctx.beginPath();
if (ctx.roundRect) ctx.roundRect(X-36, topPx-26, 72, 12, 4);
else ctx.rect(X-36, topPx-26, 72, 12);
ctx.fill();
ctx.strokeStyle = 'rgba(255,255,255,0.10)'; ctx.lineWidth = 1;
for (let i = -2; i <= 2; i++){
ctx.beginPath(); ctx.moveTo(X+i*14-4, topPx-26); ctx.lineTo(X+i*14+4, topPx-14); ctx.stroke();
}
ctx.strokeStyle = '#5a6673'; ctx.lineWidth = 3;
ctx.beginPath(); ctx.moveTo(X, topPx-14); ctx.lineTo(X, topPx-1); ctx.stroke();
/* soft glow spine through the masses */
ctx.beginPath();
ctx.moveTo(X, Y(y[0]));
for (let i = 1; i < N; i++) ctx.lineTo(X, Y(y[i]));
ctx.lineCap = 'round'; ctx.lineJoin = 'round';
ctx.strokeStyle = 'rgba(150,180,210,0.10)'; ctx.lineWidth = 16; ctx.stroke();
ctx.strokeStyle = 'rgba(170,200,230,0.14)'; ctx.lineWidth = 6; ctx.stroke();
/* one coil ring per mass: stretched top = spread rings, bottom = dense stack */
for (let i = 0; i < N; i++){
const py = Y(y[i]);
if (py < -20 || py > H + 20) continue;
ctx.beginPath();
ctx.ellipse(X, py, 15, 4.6, 0, 0, TAU);
ctx.strokeStyle = ringColors[i];
ctx.lineWidth = 2.4;
ctx.stroke();
}
}
function updateClock(){
const t = released ? (simT - releaseT) * 1000 : 0;
clockEl.innerHTML = t.toFixed(1) + '<small> ms</small>';
}
function setStatus(){
statusDot.classList.toggle('falling', released);
statusText.textContent = released ? 'falling \u2014 collapse front sweeping down' : 'held at ceiling';
}
/* ---------------- main loop: fixed-step physics, frame-rate independent ---------------- */
let speed = 1, acc = 0, last = null;
function frame(ts){
if (last === null) last = ts;
let real = (ts - last) / 1000; last = ts;
if (real > 0.05) real = 0.05; // tab was hidden: don't lurch
acc += real * speed; // slow-mo = fewer steps per frame, SAME trajectory
let guard = 0;
while (acc >= DT && guard < 20000){ step(); acc -= DT; guard++; }
draw();
updateClock();
requestAnimationFrame(frame);
}
releaseBtn.addEventListener('click', release);
resetBtn.addEventListener('click', reset);
speedEl.addEventListener('input', () => {
const s = parseFloat(speedEl.value);
speed = 1 / s;
speedLabel.textContent = s <= 1.001 ? '\u00d71.00 real time'
: '\u00d7' + (1/s).toFixed(2) + ' (1/' + (s % 1 ? s.toFixed(1) : Math.round(s)) + ' slow)';
});
addEventListener('keydown', e => {
if (e.code === 'Space'){ e.preventDefault(); release(); }
if (e.code === 'KeyR') reset();
});
reset();
requestAnimationFrame(frame);
</script>
</body>
</html>
What it actually shows
Straight talk, because you'll be holding the stopwatch, and I could not execute this file in front of you here.
What I stand behind structurally: the hanging state is solved analytically, so every mass starts with exactly zero net force; the region below the collapse front is therefore an exact stationary solution of the integrator, and the bottom cannot drift — not "looks still," but fixed-point still, to machine precision, until a real elastic wave arrives. The code contains exactly one asymmetry: the if (held) branch that pins segment 1 while you're holding it. After Release, every segment runs the identical two-line update. No clamps, no scripted timing, nothing frozen. So the qualitative behavior — top collapsing immediately (~48g initially, gone within ~10 ms), a front sweeping down through still-hanging coils, the bottom sitting on the marker line and then dropping away at g, COM at exactly g throughout — is what the code produces by construction, not by staging.
What I'd verify rather than trust: the departure time. I predict the bottom leaves the marker between ~0.15 and 0.20 s on the sim clock, with a hard upper bound of 0.21 s from the center-of-mass argument (and 0.33 s excluded). That window is my estimate, not a measurement. If you press Release and the bottom twitches before ~0.1 s, that's a bug or too-coarse a step; if it's still on the marker at 0.3 s, that would contradict the COM bound, meaning something is damping the front that shouldn't be. Either way, the clock readout at the moment the bottom moves is the number to check against me.
Known deviations from a real slinky: (1) springs are Hookean in compression too — there's no solid-height limit — so after collapse the blob has a faint internal springiness a real slinky lacks; you'll see the collapsed band shimmer slightly instead of staying dead-packed. (2) No air drag, so the COM falls at exactly g; a real slinky's falls a hair slower. (3) Motion is purely vertical — no sideways sway. (4) At full speed the first ~30 ms (the 48g top collapse) is over in about two frames; to see it, reset, drag speed to 1/20, then release — slow-mo runs the identical trajectory, just fewer steps per frame.
Parameter robustness: the fixed dt = 0.2 ms sits ~35× inside the stability limit (ω_max·dt ≈ 0.057 vs. the limit of 2), and the speed slider cannot destabilize anything because it changes only how many physics steps run per real frame. If you edit k upward, keep dt < 2/ω_max (at k = 1000 N/m you'd want dt ≤ ~0.7 ms) — nothing in the code hides instability, so past the limit it will visibly explode rather than silently fudge. Within the shipped settings, the behavior is the same at every slider position.
Bottom line: I'd bet the exhibit on the mechanism — bottom frozen on your marker line, then falling at g once the front arrives — because that's what this model is. The exact millisecond of departure is the one claim I'm offering as a testable estimate rather than a fact, and if your stopwatch disagrees with my 0.15–0.20 s window, I want to know, because then my timing reasoning was wrong even if the simulation is right.
Attachments
nex-agi/nex-n2.6 — page