Wait, Fable 5 is back! But wait, it’s going away again — for us mere Pro subscribers, at least. At the same time, there’s a new model on the market: GPT-5.6, complete with the fancy names Sol, Terra, and Luna. Unlike Fable 5’s upgrade over Opus, GPT-5.6 feels more incremental. The interesting improvement isn’t raw intelligence. It’s tool use.
That ties in nicely with OpenAI releasing its Claude Cowork rival, ChatGPT Work (apparently the best name OpenAI’s marketing team could come up with.) In theory, GPT-5.6 should be much better at coding and other tasks that require tools.
But is it? More importantly, can it hold a candle to Fable 5? Fable 5 received a ridiculous amount of hype. I happen to agree with quite a lot of it, but I hadn’t yet put it through a direct one-shot comparison.
This time, I wanted something even more dependent on physics and mathematics. And, just to establish a baseline, I threw a bonus underdog into the mix.
Let’s build a physics simulator
No libraries, no frameworks, and no second prompt
As always with these tests, the best approach is to give the models freedom to see what choices it makes. Still, there need to be enough constraints to make the results comparable. I wanted to test their programming and mathematics. So, I settled on a fluid-motion simulator: a canvas where users could pour different liquids, stir them, mix their colors, and watch the physics unfold in real time.
Of course, libraries already exist for this (like the amazing WebGL Fluid Simulation by PavelDoGreat in the image above). But, using one would turn the task into an implementation and design exercise. That wasn’t what I wanted. The main constraint was simple: no external physics libraries. Each model had to write the simulation itself, in JavaScript, and deliver everything in a single HTML file.
I ran all three in their respective coding environments and gave each model one shot. No follow-up prompt. Whatever came back was the result.
Fable 5 nailed it
The prettiest result with the best performance
Yes. Fable 5 nailed it. In a single HTML file, I had a complete fluid simulator with four colors, gravity and viscosity controls, adjustable flow and brush sizes, and tools for pouring, pushing, and erasing fluid.
Critically, the result actually looked like liquid. Underneath, Fable was still simulating particles. Each particle had a position, velocity, color, density, and pressure. Nearby particles pushed and pulled on one another to maintain something resembling a fluid density.
The clever part was that Fable didn’t draw those particles directly. Instead, it splatted them into a low-resolution field, merged nearby contributions, applied a threshold, and enlarged the result with smoothing and glow. Rendering the field at one-quarter resolution also reduced the amount of pixel work. That helped it remain usable on weaker machines without sacrificing the overall effect.
The solver was carefully designed, too. It divided the screen into small cells so that each particle only checked its immediate neighbors. Without that shortcut, 4,000 particles would need millions of comparisons during every step. Fable’s spatial grid avoided most of that work.
It also stored particle data in preallocated typed arrays and processed each neighboring pair only once. This was clearly written with performance in mind, not added as an afterthought. The result felt cohesive, heavy, and appropriately fluid. Colors gradually diffused into one another, and the surface deformed convincingly as I poured or pushed it around.
But… it wasn’t perfect. Fable tied its two physics substeps to the display frame rate. At 60Hz, everything behaves as intended. On a 120Hz display, however, the simulation can run twice as quickly while doing twice as much physics work.
It also loaded Tailwind from a CDN. The physics itself was written from scratch, but the page wasn’t completely dependency-free. But these shortcomings didn’t change the overall result. Fable 5 produced the best-looking simulator of the three. Exactly what I expected, then.
GPT-5.6 was the real surprise
Much better than expected
For the record, I tested these models in their Work and Cowork-style environments so that the tool-use upgrades would actually matter. GPT-5.6 Sol worked quickly. From my earlier one-shot experiments, I had grown accustomed to GPT producing something that was technically complete but needed another prompt before it became properly usable.
This time, I was in for a surprise. GPT really outdid itself. Like Fable, it chose a particle-based fluid simulation. Unlike Fable, it made no attempt to hide the particles.
Each particle appeared as a small colored bead. Nearby particles resisted compression, shared velocity, and slowly exchanged color. The result used the same broad trick as Fable: estimate how crowded each particle’s neighborhood is, then move particles until the density looks more fluid-like.
GPT’s implementation was simpler, but it was also coherent. The density, pressure, viscosity, and color-mixing values were all operating on compatible scales. You could see behavior resembling cohesion as particles clumped together. Boundary handling and friction also made the layers against the floor and walls behave differently from those in the middle.
You could actually watch local interactions spreading through the material. Its spatial grid was less efficient than Fable’s typed-array approach, but it was easier to read and still perfectly reasonable at that particle count.
GPT’s code had one technical advantage over Fable’s: GPT handled time more carefully. Its physics advanced according to elapsed time instead of blindly running the same amount of work after every displayed frame. That means a 120Hz monitor doesn’t make the fluid run twice as fast. Here, GPT’s implementation was better than Fable’s.
My only complaint was the appearance. The fluid looked like beads. That’s better from a teaching perspective because you can see the individual particles and observe how they interact. Visually, though, it never becomes one continuous body of liquid.
Interestingly, GPT didn’t use any external dependency at all. Its CSS, interface, simulator, and rendering code were contained in the one HTML file. Also, even more interestingly, ChatGPT automatically hosted this as a web page that I could share with anyone I wanted to. I used GPT-5.6 Sol on High reasoning. Considering my expectations going into the test, I was extremely impressed.
Bonus round
Grok… is this true?
Now here’s the surprise. xAI has been pushing Grok hard as a competitor to the major models, and coding is now supposed to be one of its serious capabilities. Grok 4.5 is the latest model.
It was fast. It opened a browser tab to test and debug its work, too, so I expected the final result to be solid. Unfortunately, it wasn’t.
At first glance, Grok’s output may have been the most ambitious. It offered six colors, three tools, adjustable gravity, viscosity, pressure stiffness, brush size, mixing, and particle limits. It also included motion trails, optional glow, visible boundaries, and four presets. On the surface, it looked like the most feature-packed submission.
|
|
Grok doesn’t have a Cowork-style desktop environment, but it does have a command-line coding tool. |
The footer proudly announced that it used “Native 2D SPH” with Poly6, Spiky, and viscosity kernels. Those are not random science words. Grok was attempting a simulation more ambitious than either Fable or GPT.
Instead of directly moving particles until they reached the desired density, Grok tried to calculate density, convert that into pressure, convert pressure into force, and integrate that force into velocity.
That approach can work, but it is also much less forgiving. Particle mass, smoothing radius, density, pressure stiffness, timestep, and world units all need to agree. Grok’s did not. Its equations naturally produced densities around 0.02, but it configured the desired density as 2.8 — more than 100 times larger. It then hid the mismatch by forcing every density value to be at least 0.12.
That meant every particle started with exactly the same density of 0.12 while the solver expected 2.8. To the simulation, the entire liquid appeared catastrophically under-dense. The central measurement driving the entire fluid solver was wrong before the first visible frame had finished. It was a similar mistake as to ChatGPT’s back when I made the solar system simulator.
It was slow, too. I wonder what Grok tested when it opened a browser tab. The page loaded, so perhaps that counted as a success?
GPT 5.6 is the real winner
The better bargain was also the bigger surprise
If I judged these submissions purely by the result on the canvas, Fable 5 would win. Its fluid looked like fluid. Its solver was the most efficient, and its low-resolution surface renderer was a genuinely smart way to turn particles into a convincing liquid.
But Fable 5 being excellent is not surprising anymore. We’ve grown to expect that from it. For a model priced at $10 per million input tokens and $60 per million output tokens, it had better look good. GPT-5.6 Sol costs nearly half as much, can be used through a ChatGPT Plus or Pro subscription, and the US government isn’t going to suddenly take it away.
GPT did, after all, produced a complete, tested, dependency-free application in one shot. Its fluid didn’t look as convincing as Fable’s, but the simulator worked. The controls made sense. The timing system was better, the interface was more complete, and the physics were easy to observe.
Grok served as a useful baseline, although probably not in the way xAI would have wanted. At the least, it showed that opening a browser and calling the result “tested” means very little. Tool use only matters when the model knows what to measure.
So yes, GPT-5.6 Sol was the real winner here. It won because Fable met my very high expectations, Grok fell through the floor, and GPT was the only model that actually impressed me.
