One prompt, eight local models: an animated solar system

Results at a glance

Source: data/llm-bench/lab/solar-system/raw/ (token counts and wall times), observations.json (verdicts recorded when each output was opened in a browser).

How to read this page

Each card below the hero is one model. The badge gives the verdict recorded when the output was opened in a browser: Works means an animated result meeting the brief, Partly works means it ran but missed part of the brief, and Failed means the brief is not visible on screen. In this run 7 of the 8 builds worked, 0 partly worked and 1 failed.

The two counters under each screenshot come from the raw API response, not from a stopwatch or an estimate. Output tokens is the completion token count the server reported, and seconds, incl. model load is the wall time of the one request, end to end. Wall time includes loading the model into GPU memory when the server had not loaded it yet, so treat it as request time, not as a speed benchmark.

The Run it live button swaps the screenshot for the actual page the model returned, running in a sandboxed frame with scripts only: the frame cannot touch this page, cookies or storage. The View source link opens the same extracted file the frame loads. Nothing on this page was edited after the fact; the outputs are byte copies of what the models returned and the thumbnails are screenshots of those files opened at a fixed window size.

The experiment

We gave eight locally hosted models one identical request:

> Write a single self-contained HTML file that shows an animated solar system on a canvas: the sun in the center and the eight planets on circular orbits, each moving at a different speed, with each planet labelled by name. Use only HTML, CSS and plain JavaScript in that one file, with no external libraries, fonts, images or network requests. The animation should fill the window and resize with it. Reply with only the complete HTML file in one code block.

A one-file canvas animation is a useful test because it exercises three abilities at once. Instruction following: the prompt carries hard constraints (one file, no libraries, no network requests, full-window resize, every planet labelled, code block only) and a model can break any of them. Working code: the reply is a program to be opened, and it either animates or it does not. Visual judgment: eight labelled planets at different speeds is the floor; what the model adds above it, orbit rings, a starfield, Saturn's ring, shows the care it puts into unrequested output. That mix of compliance, correctness and craft is close to a real internal tool request, so it informs an IT lead better than a score.

The whole run happened on Petronella Technology Group, Inc. hardware: a GB10 pod, one DGX Spark and an RTX PRO 6000 Blackwell server. Every model ran from local weights and nothing was sent to a cloud. This is exactly the setup you would run inside your own network.

What each model built

We opened every returned file in a browser and recorded what a person saw: "worked" when an animated sun and eight labelled planets moved on their orbits, "partly worked" when it ran but missed part of the brief, "failed" when there was no solar system on screen.

GLM-5.3-Flash

GLM-5.3-Flash ran on the DGX Spark / GB10 pod and worked. It produced the longest answer of the eight at 10420 completion tokens, spent on polish: a dark, restrained design with a glowing sun, faint orbit rings, small labelled planets, Saturn drawn with a ring, a title block and on-screen hints (scroll changes the time scale, space or a click pauses). Those controls are voluntary extras, and they functioned. The trade off is size.

gpt-oss-120b

gpt-oss-120b ran on the RTX PRO 6000 Blackwell server and worked. Its answer was 2642 completion tokens and it finished cleanly. What a person saw was minimal and correct: a black background, thin orbit rings, small labelled planets and no extras. The observation note puts it well: a short answer that meets the brief exactly. In the code the minimalism is discipline: the file handles window resize and keeps the loop tight.

Qwen3.8-27B FP8

Qwen3.8-27B FP8 ran on the RTX PRO 6000 Blackwell server and failed, but the failure mode is the most instructive in the run. The reply hit the output budget and stopped mid-way through the planet data, with the finish reason recorded as length rather than stop, at exactly 16000 completion tokens. The page shows an ambitious control panel (a title, a speed slider, a labels toggle, a reset view button, hover and follow hints) but no solar system, because the code that draws it was never emitted. The answer was cut off, not wrong, and the observation note judges a larger budget would likely finish it.

Gemma 4 31B (Q8)

Gemma 4 31B (Q8) ran on the RTX PRO 6000 Blackwell server and worked. Its answer was the shortest complete one in the run at 1984 completion tokens, and what a person saw was correct and plain: orbit rings, labelled planets and a starfield. Its wall time was the slowest of the RTX PRO 6000 runs at 280.1 seconds, and the observation note explains why plainly: the Ollama server loads a model into GPU memory on demand, this model had to load first, so the request included the cold start. That is a measurement caveat, not a speed claim.

Gemma 4 26B-A4B (Q8)

Gemma 4 26B-A4B (Q8) ran on the RTX PRO 6000 Blackwell server and worked. The answer came in at 4708 completion tokens, and the result was clean and correct: a starfield, orbit rings, labelled planets, Saturn with a ring. Its one visible defect is worth quoting exactly: inner planet labels overlap near the sun. The sibling comparison is telling: the 26B variant produced more than twice the tokens of the 31B dense variant and carried a labeling flaw the plain version did not.

Qwen3.6-35B-A3B (Q8)

Qwen3.6-35B-A3B (Q8) ran on the RTX PRO 6000 Blackwell server and worked. The answer was 2652 completion tokens, and what a person saw was dense and complete: a starfield, orbit rings, labelled planets, Saturn with a ring. The observation note calls it fast and complete, and its 42.9 second wall time was the second fastest of the run. This is the balanced profile of the field.

Nemotron 3 Nano 30B

Nemotron 3 Nano 30B ran on the RTX PRO 6000 Blackwell server and worked, with the plainest page of the eight. Its answer was 3229 completion tokens and its wall time of 34.9 seconds was the fastest of all eight runs. The code is correct: each planet moves on a circle at its own period. Every planet starts at the same angle, so for the first moments the eight sit in a straight line beside the sun and the labels crowd together; within seconds they spread out onto their orbits. What it skipped is the finish: no orbit rings, no starfield, and a sun drawn so large that Mercury's orbit grazes its edge.

Qwen3.6-27B

Qwen3.6-27B ran on one DGX Spark and worked, producing the most finished look of the eight: a glowing sun with its own label, shaded planets, Saturn's ring, a starfield. The answer was 3250 completion tokens, and it was also the slowest wall time of the run at 398.2 seconds. The observation note says why in one line: a dense 27B model on one GB10. Its 35B-A3B sibling on the RTX PRO 6000 answered in 42.9 seconds and met the same brief.

What the results say

Longer answers were not better. The longest reply, GLM-5.3-Flash at 10420 completion tokens, was among the most polished on screen, but the most finished look came from Qwen3.6-27B at 3250 tokens, and beyond that the correlation disappears: Nemotron 3 Nano 30B wrote 3229 tokens for the plainest working page, Gemma 4 31B wrote 1984 and met the brief, gpt-oss-120b wrote 2642 and met the brief with less decoration. Token count tells you how much a model chose to do, not how well.

Qwen3.8-27B's cut-off answer is a budget problem. The model did not produce broken code, it ran out of room at exactly the 16000 token ceiling, with the finish reason recorded as length, mid-way through the planet data. Everything emitted was coherent and ambitious. A higher ceiling would very likely have produced a working page, so test any model with the limit you will run in production.

The small Nemotron answered fastest and did the least. At 34.9 seconds it beat every other model with a correct but bare page. Against Qwen3.6-35B-A3B that is 34.9 versus 42.9 seconds on the same server, and the eight extra seconds bought orbit rings, a starfield and Saturn's ring.

A dense model on one GB10 was slowest. Qwen3.6-27B on one DGX Spark took 398.2 seconds for an answer its active-sparse sibling produced on the RTX PRO 6000 in 42.9 seconds. The smaller machine and the dense architecture stack there, and the run was not designed to separate them. Model and hardware choice are one decision.

How we ran it

Each model received exactly one request with the prompt quoted above, at temperature 0.6, with an output budget of 16000 tokens. No follow-ups, no corrections, no retries: a single request simulates an internal user pasting a request into your endpoint. Outputs are shown exactly as returned, with the code block markers removed and nothing else touched.

The timing note, stated plainly: wall time is one request end to end, including loading the model into GPU memory when the server had not loaded it yet, because the Ollama servers load on demand. It is not a speed benchmark. Gemma 4 31B's 280.1 seconds and Qwen3.6-27B's 398.2 seconds both include cold starts the faster runs did not pay.

The reply files are published alongside this page: the raw API responses with token counts and finish reasons, the extracted HTML files, and the observation notes. Every number here traces to one of those files.

Try it yourself

The prompt works on any local model, on any hardware that can host one. Copy it into your endpoint, set temperature 0.6 and a 16000 token budget, then open the reply in a browser and judge it: did every planet orbit at its own speed, is every planet labelled, does the window resize cleanly, and what did the model add unasked? Those four questions beat any leaderboard.

If you want this run, or prompts shaped like your workload, executed on your own hardware, contact us. Petronella Technology Group, Inc. runs private model evaluations on your machines, with nothing leaving your network and with the same published evidence trail.

FAQ

Where to go next

• LLM benchmarks hub
• Model tier list
• How we measure
• Private AI solutions
• Private LLM guide
• CMMC compliance