[KongchangAI]
· 4 min read· 2,010 words

GPT-6.2 Astra vs Sol Hands-On: Blender Clockwork, Neon Cube, and Godot Racing Compared

GPT-6.2 Astra vs Sol Hands-On: Blender Clockwork, Neon Cube, and Godot Racing Compared

GPT-6.2 Astra executes well but costs more; Sol is cheap but lazy; neither beats competitors.

A Bilibili creator tested OpenAI's GPT-6.2 Astra and Sol on a Blender clock workshop, neon cube design, and a Godot racing game. Astra spent $419 total vs Sol's $197, but Sol performed worse: neither built a real escapement, Sol took 9 hours to spend $100 and was lazy on enemies, and its racing game dropped to two FPS. Astra was more complete but still trails Fable and Opus in detail and controls.

Test Background: Two New Models, a Massive Gap

OpenAI released two new models at once: GPT-6.2 Astra and GPT-6.2 Sol. According to hands-on testing by a Bilibili creator, both ran the same set of briefs designed by Collectable 5.2 last week — same rules, same tasks — and the results were surprisingly far apart. One spent only $5 on the clock test; the other spent over $400 on the same test. One game dropped to two frames per second; the other ran fine.

OpenAI's official page positions them this way: Astra targets the hardest professional work, while Sol is an everyday model priced at a quarter of Astra. Next to the official benchmark numbers, Collectable 5.2 and OPS 5.5 are listed for comparison: Astra wins on most tasks and costs far less per task. But on BenchC's frontier code evaluation, Collectable 5.2 still ranks first; the same holds on the human analysis index.

The creator's stance was clear: don't trust the tables, just run your own tests. There were three tests: Clockwork (a clock workshop in Blender), Neon Cube (a New York-style neon cube design), and Formula (a racing game in Godot). Both games run in Godot, both are based on Astra Hi-F4, with up to three helper agents, image generation off, all running on the creator's current subscription, with every dollar estimated at paid prices.

Running Blender headless mode in parallel

Collectable 5.2 and OPS 5.5 are the two competitor models that recur throughout the article, each from a different vendor. The Collectable series is known for its coding ability, and version 5.2 ranks first on BenchC's frontier code evaluation; the OPS series emphasizes a balance between multimodality and game development scenarios, with version 5.5 leading on the human analysis index. Both serve as the creator's reference points for aesthetics and controls across the clock, neon cube, and racing game tests — especially on hand models, lighting atmosphere, and driving feel, where they are considered superior to GPT-6.2 Astra.

BenchC is a third-party benchmark focused on frontier code generation and engineering tasks, covering algorithm implementation, system debugging, and long-horizon project construction. Unlike official benchmarks, it emphasizes model autonomy in real development workflows. Collectable 5.2 topping this leaderboard shows it still holds an edge in code logic and engineering detail.

Test 1: Clockwork — Both Can Model, Neither Can Tick

Clockwork is set in a workshop inside an old clock tower before sunrise in Poland. Given only a prompt — no reference images, no instructions, no MCP — the model has to write its own Python scripts and run Blender headless, entirely from the command line, all on its own.

Astra's overall result looked good, with lots of detail created in the background, but the clock looked a bit heavy. Sol's clock was even heavier. Opening both side by side, the layouts were nearly identical: a large dial toward the back center, gears beside it, glass on the left — almost everything in the same position. After checking the requirements, the creator found the prompt only asked for a large tower clock dial, a ticking clock on the counter, and glass; where each part went was up to the model. Checking the logs, neither had ever opened the other's folder.

More interestingly, an earlier GPT-6.2 version had a different layout but similar colors: similar greens, golds, and spectral hues on the dial, and the two star clocks even got the same number — No. 7. This suggests the same model family has convergent aesthetic preferences on similar tasks.

But the real question: can the clock tick? The creator opened both files and measured every wheel. The gears were fine — three wheels meshed, turning in opposite directions, speeds matched, ticking perfectly accurate. Yet the white hammer just swung on its own without driving anything; there was no escapement. In other words, both were just gearboxes with a white hammer, not clocks. By contrast, GPT-6.2 Astra's earlier Faber and Opus builds produced real escapements — clocks that actually tick.

On price, Astra cost $18 and Sol under $5 — genuinely cheap. The creator also compared costs across past clock tests: Faber 5.2 cost $36, Opus 5.5 more, GPT-6 Astra $30, Sol $16, and the boss Faber 5.1 even more. Sol was the cheapest model in this test, and in the creator's view, also the worst.

All 10 clocks we've made

Escapement is the core speed-regulating mechanism of a mechanical clock, consisting of an escape wheel, a pallet fork, and a pendulum (or balance wheel). It converts the continuous rotation of the gear train into periodic pauses and releases, making the clock "tick" and keep accurate time. Without an escapement, the gear train just spins freely, and the pendulum's swing cannot feed back to control the train's speed. In the article, although Astra and Sol produced correctly meshing gears, the white hammer swung independently and was not linked to the train, so in essence they were gearboxes rather than real clocks. Faber and Opus previously succeeded in building escapements, showing a generational difference in how well models understand mechanical linkage logic.

Test 2: Neon Cube — Astra Is More Complete, Sol Is Slow and Lazy

Neon Cube required designing inside a cube where every wall is a street in a neon city at night, with the ability to walk up the walls, on a budget cap of $200.

Astra spent $100 and the result: looked good at first, the walls seemed fine, the combat design felt decent, the hand gripped the gun properly, but there were too few enemies, right-click didn't zoom, and the night was a bit too bright.

Sol was very slow, taking 9 hours to spend its first $100. The creator gave it more budget and suggested it use its carry capacity to spend the budget, but there were almost no enemies — turns out enemies only appear after the player opens the altar. On color, GPT models have their own palette; Sol 6.1, Sol 6.2, and Astra 6.2 look similar, a bit brighter with less orange. Astra 6.2 was the best, but Opus and Fable were warmer and more orange, a style the creator prefers.

After sending notes for further work, Astra's final game had working right-click zoom, a darker night, the full $200 budget spent, and was generally quite good — though not yet at the level of Opus and Fable. Sol's final game had enemies on the street from the start and only spent $145 of its budget. One highlight in Astra's game: puddles reflected the city's real signs and buildings, and Astra even wrote its own shader specifically for this; Sol's streets just glowed, with some light reflections visible. For the creator, Fable and Opus still came out ahead — he simply prefers that style and static look.

Each has its own style

Shader is a small program running on the GPU that controls effects like color, lighting, and reflections for pixels or vertices. In the article, Astra wrote a custom shader specifically for the puddles so they could reflect the city's real signs and buildings in real time, which requires the model to understand the rendering pipeline and write GLSL/HLSL code. Sol's streets simply glowed, lacking dynamic reflections, indicating it did not actively implement complex rendering logic. Custom shaders are a key technical differentiator in game development between "it runs" and "it has texture," and are also a sign of Astra's higher completeness.

Test 3: Formula Racing Game — Astra Can Fix It, Sol Drops to Two Frames per Second

Formula is a racing game where you compete against drivers; the model had to build the car, the track, and the crowd, with a $200 budget, though Astra and Sol each actually got $100.

Astra's first version looked good, but the creator couldn't drive it: every corner sent him spinning, the background was a bit weak, and the fingers on the steering wheel in cockpit view were terrible. On Sol's side, the creator made a mistake — telling Sol it could handle it, since Sol spent its budget slowly. And indeed it did, spending only $28 in 27 minutes. Objectively, that's not bad for $28, much better than the last Sol 6.1: there were hills, low-poly trees, a very nice sky, and the controls were actually better than Astra's because you could really drive it. But it still felt like a toy, with no sense of speed, weak engine sound, and badly made hands on the steering wheel.

After fixes, Astra's final version finally drove properly, no longer spinning at every corner, with newly added mountains that looked great, four types of trees with buildings in the midground, and the full budget used up. Sol's final car felt heavier, the camera changed with speed, the engine was louder, and the clothes were new. But there was one problem: at some point in Sol's game, every attempt dropped to about two frames per second, and eventually the creator gave up rather than fix it further.

For Formula, the creator felt Fable and Opus still won, with the gap in details — for example, the hand models were hugely different, and not just in static images: the AnswerPic model's controls were simply much better. The creator acknowledged they are slower, but the feel of the game was better, at least for the games he tested.

And a very beautiful sky

The Bill and Conclusion: Astra Executes Well, Sol Is Cheap but Lazy

The total bill across three tests: Astra $419, Sol $197. The creator noted that Astra spent money fast, hitting the $200 cap in about 5 hours on both games.

His assessment of GPT-6.2 Astra: a strong model that gets things done, listens to feedback, and uses every dollar you give it. Of Sol: cheap and lazy, but making this kind of store for just $5 is crazy. Compared with Fable and Opus, he still considers them superior, but Astra is already very close.

This comparison reveals a key point: model price and capability are not linearly related. Sol is extremely cheap on simple tasks, but on tasks requiring sustained investment and complex reasoning, it either can't spend the money or its output quality falls behind. Astra shows stronger task execution and budget utilization efficiency, though it still trails competitors in some aesthetic details. For scenarios requiring a model to autonomously complete complex engineering, the quality of task completion matters more than the per-call price.

The human analysis index (an umbrella term for human evaluations such as Humanity's Last Exam) differs from automated benchmarks: it is designed by domain experts with high-difficulty questions covering math, logic, code, and visual reasoning, used to measure a model's ceiling on open-ended complex tasks. The article notes that Collectable 5.2 tops this index, and while Astra wins on official benchmarks, it does not surpass competitors on the human analysis index — showing a gap between official tables and third-party human evaluations. This also explains the creator's attitude of "don't trust the tables, just run your own tests" — benchmark scores cannot fully reflect a model's budget utilization efficiency and aesthetic consistency in long-horizon engineering tasks.

One-line Summary

GPT-6.2 Astra executes well but is expensive; Sol is cheap but lazy; neither beats the competitors.

Paragraph Summary

A Bilibili creator tested OpenAI's newly released GPT-6.2 Astra and Sol with the same set of briefs across three tasks: a Blender clock workshop, neon cube design, and a Godot racing game. Astra spent $419 total versus Sol's $197, but Sol performed noticeably worse on several tasks: neither built a real escapement in the clock test; Sol took 9 hours to spend its first $100 in Neon Cube and was lazy on enemy design; and Sol's racing game dropped to two frames per second. Astra was more complete, listened to feedback, and spent its full budget, but the creator still considers Fable and Opus superior in detail and controls. The conclusion: model price and capability are not linear, and task completion quality matters more than per-call price.

#GPT-6.2 Astra#GPT-6.2 Sol#Blender clock test#Neon Cube#Godot racing game#AI model comparison#OpenAI benchmark
Share:

Related articles