GPT-6.1 Sol Hands-On: 3 Web 3D Cases — Can It Replace Astra?
TL;DR: I ran GPT-6.1 Sol (
gpt-6.1-sol) through three high-difficulty Web 3D scenarios inside Claude Code — watermelon jelly soft-body physics, a 3D cyber mokugyo, and a flower shop exploded view. All three produced working artifacts you can open directly, all single-file HTML with zero external dependencies, runnable out of the box. Soft-body rebound under force, native Web Audio synthesis, and spatial continuity in a 3D scene — the three things that used to fail most often — all held up.The live URLs for all three demos, the full copy-paste prompts, and the real quota bill on a Plus plan are all below.
Keywords: GPT-6.1 Sol hands-on, GPT-6.1 Sol frontend, GPT-6.1 Sol vs Astra, Three.js single-file HTML, AI frontend motion
Who this is for: developers who want to use GPT-6.1 Sol for frontend motion or Web 3D in real projects, and anyone weighing whether it justifies a plan upgrade.
The Three Cases at a Glance
| Case | What it tests | Live demo | Prompt |
|---|---|---|---|
| Watermelon Jelly Squishy | Soft-body physics: 2D mass-spring system, mesh deformation, damped rebound | Open demo | Jump to Case 1 |
| 3D Cyber Mokugyo | Light and audio: complex Three.js lighting, native Web Audio synthesis | Open demo | Jump to Case 2 |
| Flower Shop Exploded View | Spatial continuity: multi-level component management, reverse animation | Open demo | Jump to Case 3 |
How to watch: all three demos are desktop-browser experiences. Drag the first one, and turn your sound on for the other two.
📚 Table of Contents (click to jump)
- Test Setup: How These Three Cases Were Built
- Case 1: Watermelon Jelly Squishy (Soft-Body Physics)
- Case 2: 3D Cyber Mokugyo (Native Audio Synthesis)
- Case 3: Flower Shop Exploded View (Spatial Continuity)
- The Three Cases Side by Side
- What This Test Did Not Cover
- Cost: How Much Quota the Three Cases Burned
- Verdict: Where GPT-6.1 Sol Actually Stands
- FAQ
Test Setup: How These Three Cases Were Built
Setup first, so your reproduction lines up with mine.
- Model:
gpt-6.1-sol(not Astra, and not GPT-6 Sol) - Client: Claude Code, not the Codex App
- Quota: the Codex membership allowance inside a ChatGPT Plus plan
- Project layout: one directory per case, each containing a single
index.html
Why run it in Claude Code? Because that's where my daily workflow lives, and the open-source CLIProxyAPI tool can convert a Codex membership into a local API key losslessly — your own client, Codex's quota, with no extra API spend. How to wire it up: CLIProxyAPI guide: turn a Codex membership into a local API key for Claude Code.

All three cases below ran under the same brief: single-file HTML, zero external dependencies, runnable out of the box.
Case 1: Watermelon Jelly Squishy (Soft-Body Physics)
What it tests: 2D mass-spring systems, mesh deformation, jelly-like damped rebound.
What I wanted to verify
The most frustrating part of using an LLM for web motion is the plastic feel: ask for a deformation and you usually get a couple of stiff CSS scale transforms, or a few bezier curves papering over it — it moves, but it has no weight.
So this time I left it no escape route and turned the difficulty all the way up: build a piece of glistening watermelon jelly using pure math and a mesh system, squeezable and stretchable with the mouse anywhere, with damped rebound.
What I asked for (copy-paste ready)
Build a runnable single-file HTML page implementing an extremely realistic, bouncy, stress-relieving "watermelon jelly squishy" interactive animation.
Technical and physics requirements:
1. [Visuals]:
- At the center of the screen is a slice of watermelon: luscious translucent red flesh (with jelly-like specular highlights and tiny bubbles), a few scattered black seeds, and a rind that fades from pale white at the base into vivid green.
- The rendering must read as translucent gelatinous jelly (subsurface-scattering look, soft shadows).
2. [Core soft-body physics]:
- Based on a mass-spring system or 2D soft-body physics (Verlet integration), where the flesh is a mesh of dozens of interconnected control points.
- Mouse (or touch) interaction:
- Hold and drag anywhere on the watermelon outward, and the flesh stretches and thins elastically under the pull;
- Release the mouse button and the flesh produces a high-frequency, damped jelly wobble (a "boing~boing" rebound) before easing smoothly back to its original shape;
- When the mouse sweeps across quickly, the surface ripples with tiny wave-like jelly tremors.
3. [Interaction feel]: a clean, uncluttered UI with no extraneous elements, on a light-grey macaron background, so the user's first instinct is "I want to squeeze it". All code self-contained in one HTML file.
What it produced
Try it live: Open the watermelon jelly demo

Pull the flesh outward and it stretches and thins like a real gummy; the moment you let go, the whole block wobbles at a high frequency and boings back into shape.
What it got right
- It hand-built a real physics system. It didn't take the lazy route and import an existing physics library — it constructed an interconnected mass-spring mesh (Verlet integration). Whether you pull a corner or squeeze the middle, the indentation at the contact point and the drag on the surrounding flesh line up, with that dense, fluid feel.
- The material optics weren't faked. Translucent gelatinous highlights, the rind gradient from white to vivid green, the tiny bubbles suspended in the flesh — all rendered.
What it missed
I didn't ask for sound in the prompt, so this version is silent — that's on me, not the model. Want audio? Borrow the approach from Case 2.
Verdict for this round: on soft-body physics, what it handed back was a finished piece, not a demo.
Case 2: 3D Cyber Mokugyo (Native Audio Synthesis)
What it tests: complex Three.js lighting, native Web Audio API synthesis, micro-interaction rhythm.
What I wanted to verify
If the watermelon was self-indulgence, this case was built along the lines of a commercial hit. What young people want most right now is stress relief and an emotional outlet; tapping-a-mokugyo style soothing toys have gone viral more than once, so the demand is already proven.
So I asked GPT-6.1 Sol for a 3D immersive cyber merit temple that can run unattended in a browser tab: not just 3D modelling, but physical vibration, shockwave particles, and an ethereal mokugyo tone synthesized entirely by the browser, with no external audio files.
What I asked for (copy-paste ready)
Write a highly polished, browser-runnable single-file index.html "3D Cyber Mokugyo · Immersive Merit Temple". Use HTML5 + Three.js (cdnjs) + GSAP (cdnjs) + Web Audio API.
Core effects and interaction requirements:
1. [3D mokugyo and scene]:
- At the center, a finely modelled floating 3D wooden mokugyo (rosewood texture, with subtle specular bevels and shadow).
- Background in a dark zen-tech style (deep-space gradient, dotted with a drifting stream of faint golden incense particles).
2. [Strike effects and physics feedback]:
- Listen for mouse clicks (or the spacebar):
- The mokugyo itself sinks sharply under the impact and rebounds with a bouncy damped motion (using GSAP).
- Each strike bursts a golden shockwave ring and golden starburst particles from the contact point.
- Translucent glowing 3D golden text rises above the mokugyo: "Merit +1", "Worries -1", "Salary +10000" (rotating at random), floating upward while fading out.
3. [Audio synthesis (native, no external files)]:
- Use the Web Audio API to synthesize an extremely ethereal, crisp and deep "tok, tok" mokugyo strike, with a soft reverb tail.
4. [UI]:
- A modern, faintly glowing "accumulated merit counter" at the top, in a minimal designed typeface.
- A [Auto Meditation Slacking] toggle in the bottom right; once enabled it strikes automatically at a zen pace of once per second — ideal for leaving on a second monitor at work.
All code self-contained in one file, ready to tap out of the box.
What it produced
Try it live (turn your sound on): Open the 3D cyber mokugyo demo

In a deep, dark zen space, a mokugyo with a warm rosewood sheen floats mid-air. The instant you strike it, the mokugyo sinks and rebounds, a golden shockwave ring ripples outward, and a crisp, resonant "tok" rings out; glowing text — "Merit +1", "Worries -1" — drifts up the screen. There's even an [Auto Meditation Slacking] toggle in the bottom right.
What it got right
- The audio is synthesized on the spot. It didn't go hunting for some external mp3 that 404s half the time — it built the wooden strike and its decaying tail live from an Oscillator and a GainNode, using the Web Audio API's native capabilities with no external dependency.
- The strike has rhythm. With GSAP easing curves behind it, the impact is crisp and forceful, and the rebound carries a hint of wooden tremble without dragging.
- Commercial completeness. From the merit counter to the particle-fade algorithm to full responsive scaling, the logic closes the loop tightly enough that wrapping it in a shell would ship it as a standalone mini-app.
Verdict for this round: audio is normally the part that breaks a demo like this; here it was the most complete piece.
Tap away for a workday, merit fulfilled, worries gone.
Case 3: Flower Shop Exploded View (Spatial Continuity)
What it tests: global spatial continuity, multi-level component management, inverse-kinematics animation.
What I wanted to verify
If the first two cases count as impressive, the third is the hard bone.
In 3D industrial visualization and architectural previews, the hardest technique is the exploded view. Even Astra used to fumble this: parts fly off screen, clip through each other front to back, or you get a facade with an empty shell behind it.
I gave GPT-6.1 Sol a demanding brief: build a cozy two-storey flower shop, not only with a complete roof and glass walls but with a checkout counter, flower racks, potted plants inside, right down to a small bed in the furthest corner; then animate every component floating apart and reassembling back into place without a seam.
Before looking at the result, I was braced for it to fail.
What I asked for (copy-paste ready)
Use Three.js to build a refined two-storey "cozy flower shop" 3D scene in a single HTML file, and implement a complete structural exploded-view animation.
Requirements:
1. [Scene modelling (fully procedural, pure code)]:
- Roof, four walls (the front wall with a large transparent glass display window and a shop door), floor.
- The key point is [no cutting corners on interior detail]: the inside must include a wooden checkout counter, multi-tier stepped flower racks, vases and potted plants of varying heights, and a small bed with floral bedding tucked into the furthest corner.
- Warm and fresh color palette (mint green walls, warm wooden furniture, rich floral colors).
2. [Exploded view animation]:
- Place a control panel in the bottom right: a "Disassemble / Assemble" button, or a progress slider (0% ~ 100%).
- On disassemble: the roof rises smoothly straight up and hovers; the four walls translate outward in their own four directions; the flower racks and counter spread outward; the innermost bed and small vases stay at the center. Every component floats apart smoothly, showing the interior from every angle with no blind spots.
- On assemble: every part retraces exactly the reverse path and slots back together without a seam.
3. [Render quality]: use OrbitControls so the mouse can freely rotate and zoom; set a soft HemisphereLight and a shadow-casting DirectionalLight, with a soft clay / miniature-model style.
What it produced
Try it live: Open the flower shop exploded view demo

Hit the disassemble button and the whole shop behaves as if enchanted: the roof rises straight up, the four walls with their floor-to-ceiling glass slide outward, the racks and counter fan out to the sides — and the entire interior is suddenly laid bare. Hit assemble and every part glides back into place along the reverse path, flush and unclipped.
What it got right
- No lazy spatial memory. Once the four walls retreat, you find it genuinely built that small bed in the room's furthest corner — the creases in the bedding, the position of the nightstand, all at the correct relative coordinates. It didn't skip the interior because the default camera angle wouldn't show it.
- The trajectories are computed, not guessed. Disassembly translates along the normal; reassembly returns precisely to the origin. That says its grasp of the 3D scene graph and local coordinate systems is accurate.
Verdict for this round: at this level, work in e-commerce 3D product teardowns, interactive courseware or digital-twin prototypes — the kind that used to take a 3D artist plus a frontend developer several days — now yields a prototype from natural language in minutes.
The Three Cases Side by Side
Line the three prompts up and you'll see my requirements always follow the same playbook:
- Write visuals as a checkable list. Not "make it look good", but materials, lighting, palette and composition spelled out.
- Write interactions as physical actions. Not "make it satisfying", but how it deforms while dragging and how it rebounds on release.
- Hard-code the constraints. Single file, zero external dependencies, runnable out of the box — leave no room to "just import a library and muddle through".
That playbook is more worth copying than the prompts themselves. Swap in your own scene and rewrite at the same granularity, and the output won't be far off.
What This Test Did Not Cover
A hands-on piece that only reports good news has no reference value, so here are the boundaries:
- Frontend visuals and interaction only. No backend, data, or deployment testing.
- No performance numbers. Frame rate, memory usage, low-end device behavior — none of it measured.
- No mobile testing. The three demos above are best viewed in a desktop browser.
- No head-to-head against other models on the same task. Every mention of Astra is my own impression, not a benchmark score.
- No long-horizon tasks. All three cases finished within a single session; cross-session, multi-file engineering wasn't touched.
One more caution worth stating separately: running is not the same as shipping. These three demos exist to gauge the model's capability. If you're building a real product, the code still needs review.
Cost: How Much Quota the Three Cases Burned
I was on a Plus plan, drawing on the Codex membership quota included with it. After all three cases, the quota panel looked like this:

- 5-hour limit: about 40% used
- Weekly limit: about two-thirds used
- Request log: 166 successes, 2 failures, a 98.8% success rate
Compared with Astra, the previous generation's usual workhorse, this is a very reasonable burn.
To do that math more precisely, cross-reference the Codex quota comparison: on a Plus plan GPT-6.1 Sol gets a 15–160 per 5-hour allowance, the tightest tier of any model. So before running tasks like these, leave your account some headroom.
Verdict: Where GPT-6.1 Sol Actually Stands
Three takeaways from playing with these cases back to back:
- Aesthetics and engineering finally landed in the same model. Earlier models either wrote code with terrible taste, or had good ideas that wouldn't run. What stands out about 6.1 Sol: the code is right on the first pass a high proportion of the time, and the visuals are clearly a tier ahead.
- Physics and spatial reasoning are no longer guesswork. From soft-body rebound under force to each component's relative position in a 3D building, the spatial logic it displays is enough to take over Astra's old spot.
- It's the cheat code for a one-person company. For indie products, client websites, or soothing mini-tools, so long as the prompt is precise enough, the code it emits is close to commercial grade.
Conversely, don't rush to switch in these cases:
- You need complex reasoning, Computer Use, or long-chain research — that's GPT-6 Astra's home turf, and this test didn't cover it.
- Your task is performance-sensitive and needs real frame-rate and memory data — this article has none, so don't cite it.
- You haven't set up the environment yet — start inside Codex, or wire it into Claude Code via CLIProxyAPI. Either works.
Your first move: open the three demos above, pick whichever is closest to your need, copy the prompt over, and run it against your own scene. Ten minutes tells you whether it holds up.
FAQ
Can GPT-6.1 Sol actually do frontend motion and Web 3D?
On these three cases, yes. Soft-body rebound under force, native Web Audio synthesis and spatial continuity in a 3D scene all came out as working artifacts you can open directly — and all are single-file HTML with zero external dependencies.
Was this tested inside Codex?
No. All three cases ran in Claude Code calling gpt-6.1-sol, consuming the Codex membership quota included with a ChatGPT Plus plan. To wire a Codex membership into Claude Code the same way, see the CLIProxyAPI guide.
How much quota did the three cases use in total?
On a Plus plan, running all three used roughly 40% of the Codex 5-hour limit and about two-thirds of the weekly limit. The exact numbers and screenshot are in the Cost section above.
GPT-6.1 Sol or Astra — which should I pick?
Astra is the previous-generation flagship, strongest at complex reasoning and Computer Use. On these frontend and 3D cases, GPT-6.1 Sol already fills its shoes for motion work, and burns less quota doing it.
Can the demos here be used commercially as-is?
Running is not the same as shipping. All three are single-file HTML, which makes them easy to fork, but review the code before launch — especially performance and mobile compatibility, neither of which this article tested.
Why doesn't my copy of the prompt look this good?
The visual description is the whole game. The original prompts state materials, lighting, color and interaction feedback as checkable requirements. When you swap in your own scene, rewrite at that same level of detail — changing a few words makes a large difference.
Need to upgrade to Plus / Pro but running into payment trouble? See ChatGPT subscription top-up.
