A generated title card reading 'Gemini 4 Neon's Three.js Demo' with the subtitle 'Fifteen seconds, one sentence, no prompt', beside a small diagram of a claim-to-measurement gap: a video frame labelled 'posted 19 Nov 2026, 1920x1080, 15.0s' on one side and a checklist labelled 'prompt, effort level, token count, source file' on the other, most boxes empty.
Guides & Insights

Gemini 4 Neon's Three.js Demo: What 15 Seconds Actually Shows

Author

Gideon Frost

Date Published

Latest models · 20View all models →
Benchmarks: Artificial Analysis · updated daily
Back to all posts

On 19 November 2026, a developer posting as @chetaslua published a fifteen-second clip with one sentence attached: Gem​ini 4 Neon had made the motion graphic in it, in “pure @threejs,” and the robot dance at the end goes hard. The video is 1920×1080 and runs fifteen seconds. That is the whole of the public record — no prompt, no source file, no thinking level, no token count, no statement of whether it came out of the API, AI Studio or Antigravity. Gem​ini 4 Neon is a real, generally available model; Goog​le’s DeepMind model page lists it under November 2026, and Artificial Analysis has it scored and priced. But a posted clip is a claim, not a measurement, and the distance between those two things is the useful part of this story. Gemini 4 Carbon enters only as the sibling Goog​le says Neon is adapted from and the one our own catalogue actually carries — it is not the subject here.

Fifteen seconds, zero recorded settings

Start with what can be checked from the post itself, because it is a short list and it is worth seeing how short.

• The claim — that Gem​ini 4 Neon made the motion graphic, in pure three.js. This is the poster’s attribution. Nothing in the clip proves which model wrote the code, and nothing in the thread shows the code.

• The timestamp — 19 November 2026, 16:51 UTC, one day after Neon’s 18 November general availability. Nobody can accuse this of being a pre-launch demo smuggled out under an embargo; it is a same-week artifact.

• The file — fifteen seconds, 1920×1080, no narration, posted as a video attachment. A rendered output, not a screen recording of an editor. That matters: a screen recording of someone typing would show the prompt, the intermediate errors and the number of attempts. A finished render shows none of them.

• The engagement — 130 likes at the time we pulled the post text. Small. This is one person’s show-and-tell, not a coordinated demo drop, which is roughly what makes it interesting: nobody curated it for a launch post.

What is missing is everything that would let a second person reproduce it. The prompt. The effort level — Neon supports low, medium, high and xhigh, and the gap between low and xhigh on the same prompt is large enough to change both the bill and the output. The surface. The number of attempts behind the one that got posted. Whether the robot dance was asked for or improvised. Whether any of the JavaScript was hand-edited afterwards. Each of those is a single line in a follow-up post, and none of them is there.

What a Three.js scene actually tests

It is tempting to file this under “front-end capability” and move on, in either direction — as proof the model is good at graphics, or as proof that a pretty render means nothing. Neither reading survives contact with what the artifact is.

three.js is one of the most heavily represented libraries in any model’s training data. A scene with a camera, a light, a mesh and a render loop is close to the canonical “look what I made” output of the last three years of web development. Every current frontier model can produce a page that renders something spinning. The existence of a competent three.js scene in a fifteen-second clip therefore tells you almost nothing about which model made it, which is exactly why the poster’s attribution is doing all the work in that sentence.

What is genuinely harder, and what a motion graphic with a timed dance at the end actually exercises, is the part that has no correctness oracle. A motion graphic is a sequence: an animation state machine with transitions, a camera path, easing curves, an ordering of events that has to land on a beat. There is no test that asserts the dance looks right. The model has to hold a sixteen-second storyboard in its head, emit the timing constants, and not drift. When someone says the last four seconds “go hard,” they are making a judgement about choreography and pacing — and pacing is the thing single-shot code generation is worst at, because nothing in the loop fails when the timing is merely mediocre.

That is the real reason this clip is worth a second look even though it proves nothing. It is a claim about temporal composition, not about shader math. A model that can write a shader and a model that can hold a fifteen-second sequence together are different claims, and only one of them is being made here.

The numbers Neon does have

Artificial Analysis is the only independent scoreboard with a Gem​ini 4 Neon entry, and reading it carefully is the fastest way to see how far the posted clip sits from anything measured.

Screenshot of the Artificial Analysis analysis page for Gemini 4 Neon, headed 'Intelligence, Performance & Price Analysis', showing an Intelligence Index of 61 at xhigh effort with ranks of 6 of 96, 73 of 95 and 79 of 95 across the panels, 110 output tokens per second, 21.5 minutes per task, $3.00 input and $15.00 output per million tokens, and a verbosity panel reporting 283 million output tokens and a 3.482% output-to-input ratio.

The headline is 61 on the Intelligence Index at the xhigh thinking level, ranked sixth of 96 models on the board. The same model reads 60 at high, 55 at medium and 44 at low — a seventeen-point spread across its own effort ladder, which is the single most important number in this piece if you are about to quote “61” at anyone. Sixty-one is an xhigh number. Neon’s documented default is high.

The rest of the panel is where the demo habit gets expensive. Output speed is 110 tokens per second. The model takes 21.5 minutes to complete one Intelligence Index task, against a median of 12.1 minutes for models at a comparable price, and it is ranked 73rd of 95 on performance and 79th of 95 on cost. On verbosity it ranks 93rd of 95: 283 million output tokens and 8.12 billion input tokens across the index run, an output-to-input ratio of 3.48% against a median around 65 million output tokens. Artificial Analysis’s own summary calls it very verbose, and prices a single index task at $6.44. At Goog​le’s rate card that is $3.00 per million input tokens and $15.00 per million output, with cached input at $0.15.

Goog​le’s own published table is a different genre of number, and should be labelled as such: vendor-reported, not reproduced by anyone outside Goog​le. CursorBench 4.1 at 65.4%, Terminal-bench 4.1 at 65.2%, FrontierCode 2.0 at 46.2%, SWE-sweep at 39.0% in Goog​le’s own harness, AutomationBench at 56.3%, Agents’ Last Exam v1.1 at 75.8%, RiemannBench at 84.0%, GraphWalks at 95.2%. Every one of those is an agentic or coding or long-context measurement. Not one of them measures “produce an attractive animated scene in one shot from a short prompt,” because no benchmark does. The demo and the scoreboard are not measuring the same thing, and neither of them is measuring the thing the clip is being read as evidence for.

What a demo attempt actually costs

The price matters because demos are iterative, and Neon is verbose by measurement. Nothing about a fifteen-second render says how many attempts it took, and every attempt is a full generation.

• A 25,000-output-token attempt — a plausible size for one three.js scene at high effort, with reasoning tokens counted as output — is about 38 cents at $15 per million.

• A 60,000-token attempt is about 90 cents. Three or four of those, plus a couple of retries, and you have spent more on the demo than the demo is worth as evidence.

• A 200,000-token attempt — the sort of number you reach at xhigh when the model thinks its way through an animation state machine — is $3.00 on its own.

• Batch and flex tiers run at half rate, so the same three attempts at $1.50 and $7.50 per million come to roughly half. None of this is exotic; it just is not free, and the clip doesn’t say.

A generated cost card titled 'What a demo attempt costs', listing three attempts at $15.00 per million output tokens: 25,000 tokens at about 38 cents, 60,000 tokens at about 90 cents, and 200,000 tokens at $3.00, with a second column showing the same three at the half-rate batch and flex prices of $1.50 and $7.50 per million, and a footer reading 'Arithmetic at the published Neon rate card; no measurement of the posted clip.'

This is the argument for trying an unproven model through a router rather than wiring it into a production path. Neon is two days old, its verbosity is the worst-ranked figure on its own panel, and the only public artifact for this particular use case is one person’s finished render. That is a model you want to call next to something else and compare bills on, not a model you want to commit a client to in November.

What would make the next clip checkable

None of this is a criticism of the poster, who made a thing and shared it. It is a short protocol, and anyone posting the next one could close the gap in a handful of lines:

• The prompt, verbatim. Not a paraphrase — the actual text. This is the single highest-value line and it costs nothing to include.

• The model identifier and the effort level. “Gem​ini 4 Neon at high” is a different claim from “Gem​ini 4 Neon at xhigh,” and at a $15 output rate the difference is money.

• The surface. Antigravity, AI Studio and the raw API apply different system prompts and different tool scaffolding; a scene produced inside an agentic IDE is not the same artifact as one produced by a single completion.

• The attempt count and the output-token total. Two numbers, both visible in a billing console, and together they turn an anecdote into a cost per usable render.

• The source file. A single self-contained HTML page with the three.js import and the animation loop is the whole reproducible artifact, and it is usually under a hundred kilobytes.

• One failure. A second prompt the model could not do, at the same settings. A demo with no documented failure mode reads as a highlight reel, because that is what it is.

Until at least the first three of those exist, the honest summary of this clip is that a model released the previous day produced something a competent web developer would be pleased to have made, and that we cannot tell from the file how much of the credit belongs to the model, to the prompt, or to the editing.

How to re-run the test yourself

Gem​ini 4 Neon is not in the OrcaRouter catalogue as of 20 November 2026 — the Gem​ini 4 models we route are google/gemini-4-carbon and google/gemini-4-argon, and the catalogue stands at 217 model identifiers. So the practical version of this test today is a within-family comparison: run the same motion-graphic prompt on Carbon at high effort and on Neon at high effort through Goog​le’s own API, and compare output tokens, wall-clock time and how much of the render you had to ask for twice.

That comparison is easy to set up on our side for the Carbon half. One key covers the catalogue, provider list price is passed through at 0% markup, so a Goog​le rate change is live on your bill the same day rather than at the next invoice, and failover means a single bad generation does not end the run. If you are testing a two-day-old model against a settled one, the routing DSL will put both behind one endpoint and return the pair, which is the cheapest way to get a real answer instead of an impression.

Screenshot of the OrcaRouter model page for google/gemini-4-argon, showing the model header with a zero-retention agreement noted, the chat-completions and generateContent endpoints, input priced at $2.00 and output at $10.00 per million tokens, cache reads at $0.100, and code samples calling google/gemini-4-argon through the OpenAI-compatible base URL https://api.orcarouter.ai/v1 with an ORCAROUTER_API_KEY.

The thing worth watching is not whether more pretty clips appear — they will, from every lab, indefinitely. It is whether the people posting them start attaching the prompt and the effort level. The moment one does, the comparison becomes possible: the same sixteen-second storyboard, run at four thinking levels, with the token count and the bill next to each render. That single post would be worth more than the entire benchmark table Goog​le published, for this specific question, because it would be the first measurement of whether Neon can hold a timed sequence together rather than whether it can write a shader.

Until then, treat the clip as what it is: a nice artifact, a plausible capability signal, and a claim whose strongest evidence is the reputation of the person who posted it.