I Tried GPT-5.6 Sol for a Sunday and Accidentally Built Tasmania
I recently got back from Tasmania completely enraptured by its history. I actually did the sensible thing first and started reading Robert Hughes’s The Fatal Shore. Then I decided to find out what a grand strategy game set in Van Diemen’s Land from 1803 might look like.
Think something in the same broad vein as a Paradox game: a historical map, settlements, politics, resources, and a lot of interconnected systems that will probably consume years of my life if I let them.
To be clear, I haven’t built that game. I haven’t even built the beginnings of most of those systems yet.
What I have built is Tasmania.
Well, a 3D map viewer of Tasmania. But it has real mountain ranges, valleys, coastlines, King Island, the Furneaux Group, and enough ocean that you can’t zoom out and discover the horrifying edge of the world.
The surprising bit is that the first working version took about a Sunday.
This Was Supposed to Be a Small Experiment
There were really two experiments happening at once.
The first was the game idea. Before I could think seriously about regions, settlements, or simulation, I needed a map. My expectations here were modest. I assumed I would find some abstract map data, build a recognisable outline of Tasmania, make it vaguely three-dimensional, and call that a successful start.
The second experiment was GPT-5.6 Sol. I wanted to see what the model was actually capable of when given a reasonably complicated, open-ended software project. Not a toy example or an isolated function, but something involving Unity, rendering, geographic data, external tooling, architecture, testing, and all the awkward bits between them.
I expected it to help.
I did not expect to watch mountain ranges and valleys emerge from real elevation data within a day.
Apparently I Needed a Geographic Data Pipeline
The phrase “grab some map data” is doing an enormous amount of work.
Real geographic data does not arrive as a neat Unity asset called
tasmania_final_really_final.prefab. Elevation and coastline data arrive with
their own coordinate systems, resolutions, missing values, and conflicting ideas
about what counts as land. So the tiny map experiment became an offline
geographic-data pipeline.
It combines Land Tasmania’s 25 metre elevation model with statewide coastline data, records and checks every source, then converts the result into meshes and textures for Unity.
None of this happens when the game starts. The runtime doesn’t need Python, GDAL, QGIS, a network connection, or a quiet prayer to whichever deity governs GIS software. It loads normal, pre-generated Unity assets.
One Unity unit represents one kilometre, and every position can be converted back to its real projected coordinates. This is probably more care than an experiment strictly needed, but if I eventually place Hobart somewhere, I would prefer it not to be several kilometres out to sea.
Why Not Just Use Unity Terrain?
Unity already has a terrain system, so obviously I built my own.
There was a reason, I promise.
The map needed a detailed coastline, small islands, multiple levels of detail, and neighbouring pieces that did not split apart or reveal lighting seams. The solution was a set of custom tiled meshes that preserve a fine coastline while simplifying the terrain farther inland and at greater distances.
An early attempt used a regular coarse grid. It pushed the coastline too far from the source and swallowed small islands. I had started the day expecting to trace an outline. By that evening, I was rejecting terrain-generation methods based on how badly they distorted the coast.
The Map Became Slightly Larger Than Expected
The finished dataset contains 320 geographic tiles, each with four levels of detail. Only 121 contain land worth rendering. Even so, the generated map assets occupy roughly 639 MiB.
That was a fun number to discover.
My original source-control budget was 500 MiB, so the project had to adopt Git LFS for the generated mesh and mask files. The complete Windows build, including the Unity engine and all the map data, occupies about 1.92 GB on disk. That is an objectively funny size for an application whose current feature list is essentially:
- Tasmania exists.
- You can look at it.
Most of that size comes from binary land-mask images that Unity currently expands into uncompressed colour textures, including masks for 199 sea-only tiles. Fixing that should cut the build substantially, but it can wait for a later optimisation pass. For now, the prototype is allowed to be slightly ridiculous.
More importantly, it is portable. I tested clean copies on Windows and macOS without the original downloads or geographic tools. Making something work once is easy. Making it work somewhere else is where it starts to feel real.
Making Looking at Tasmania Feel Good
Once the land existed, it needed to be pleasant to explore.
The prototype has the familiar controls of a desktop strategy game: keyboard panning, mouse dragging, wheel zoom, temporary rotation, and a smooth return to north-up. Zooming preserves the point under the cursor rather than hurtling the camera towards the middle of the screen.
Visually, the map is deliberately restrained: one directional light, a simple terrain palette driven by height and slope, a flat ocean, and distance fog. There are no borders, labels, settlements, roads, units, or interface elements yet. Geography is the only job of this prototype.
There is also a comically large ocean extending thousands of kilometres beyond the map. This exists because I discovered that a sufficiently determined player could zoom out far enough to see its edge. Rather than inventing a complicated ocean system, I made the rectangle much larger. Sometimes engineering is about choosing the sophisticated solution. Sometimes it is about buying a bigger rectangle.
The Most Surprising Part Wasn’t the Map
The most surprising part of this experiment was how quickly my expectations changed.
On Sunday I was completely blown away by how much GPT-5.6 Sol and Codex could accomplish in such a short period. I could describe the goal, discuss trade-offs, review evidence, and watch it move between C#, Unity assets, shaders, Python, geographic tooling, tests, and documentation. It wasn’t just producing snippets. It was able to keep working through a long chain of dependent problems and leave behind a project that could be validated on another operating system.
Then, while tidying the project over the following days, I caught myself becoming impatient with how slowly it was working.
Slowly.
The same system that had compressed what I expected to be weeks of unfamiliar work into a Sunday had reset my expectations so thoroughly that, almost immediately, waiting several minutes for the next piece felt tedious.
That contradiction has stuck with me more than any individual technical achievement. We adapt to new capability extraordinarily quickly. Yesterday’s magic becomes today’s progress bar.
It has also changed what I’m interested in experimenting with next. I don’t only want to know what the model can build; I want to understand how to work with it well. How should a large task be divided? Which context is genuinely useful? Where does parallel work help? How much verification is enough? Which instructions prevent wasted motion, and which merely create more text for the model to carry around?
In other words, I have apparently begun optimising myself as part of the build pipeline.
So, Is There a Game?
No.
There is a robust geographic foundation for one, which is not quite the same thing.
The project currently displays real-data-derived terrain for Tasmania and the major Bass Strait islands, surrounds it with an ocean, and lets me explore it with a strategy camera. The simulation is still very much in progress. There are no regions, settlements, historical scenarios, populations, economies, units, politics, or playable decisions.
That boundary was intentional. I wanted the first experiment to answer one question: can I build a convincing, portable 3D map viewer as a foundation for a historical grand strategy game?
The answer is yes, and much more quickly than I thought possible.
What happens next is less certain. I want to keep teasing apart what a strategy game beginning in Van Diemen’s Land in 1803 could be, and I also want to keep testing what this new way of building software is good at. Those may turn out to be the same project.
Either way, Tasmania exists now.
That’s usually how these things get out of hand.
Subscribe for updates
Want more like this? Get new posts in your inbox. No spam, ever.