Around The World, Part 29: One year in

Sat, 14 Feb 2026 by Thomas ten Cate · Comments
 Game Development, Around the World

Exactly one year ago this Valentine’s Day, I started development on Around The World. Let’s look back on the past, but more importantly, look forward at what’s still ahead.

“Wait,” you ask, “haven’t you been at this for far longer than one year?” Yes, that’s true. The first post in this series was published in November 2023, over two years ago. But the code repository of that project was called aroundtheworld4, so clearly there is even more untold history here. Let’s dive in!

Iteration 1: tectonics, mostly

The first repository, simply called aroundtheworld, was started in 2019. The idea of the game was already on my mind, but mostly it was an excuse to play around with procedural world generation. I never got around to even start on gameplay, but the tectonic plate simulation made for some pretty satisfying videos:

The bright parts are continental crust, the dark parts are oceanic crust, and the colours are determined based on the plate. Note that a tectonic plate isn’t either oceanic or continental; it can contain both types of crust attached to each other. Each tectonic plate is modelled as a set of discs of radius r, and the rule is that two discs may never overlap.

A birds-eye view of the algorithm:

• Generate discs on a sphere using Poisson disc sampling. For r = 0.01 radians, this gives about 43000 points.
• Generate 12 random tectonic plates, each with a type (continental or oceanic), a height above/below sea level, a centroid on the sphere, and a velocity (axis + angle).
• Assign each disc to the nearest plate center. To make plate edges less straight, add a random offset to each disc before looking up the nearest plate centroid. The random offset comes from a couple octaves of 3D simplex noise.
• For each time step:
  • Move all discs according to the velocity of the plate they belong to.
  • Detect collisions between discs. If two discs overlap, then one of the two survives. Which one depends on crust type and height/depth: oceanic crust subducts underneath continental crust and disappears; deeper oceanic crust subducts under less deep; and for continental/continental collisions we flip a coin.
  • Colliding discs also apply a force to the plate, causing colliding plates to slow down relative to each other.
  • Adjust the height/depth of the surviving disc: subducting oceanic crust pushes up continental crust to form coastal mountains; colliding continental crust also forms mountain ranges.
  • To create new crust near divergent boundaries, we just run another round of Poisson disc sampling, spawning new discs near existing ones. The crust type and height/depth here also depends on the existing point, to create ocean ridges and rift valleys.

Although it was fun to work on and to look at, I eventually realized that this approach was not suitable for a game: it was too slow, and gave me too little control over the output. So within the same repository, I started on a new approach that was mostly just layers of noise. It got as far as a basic height map:

The approach you see here survives to this day:

• Generate random jagged Voronoi regions called “subplates”.
• Accumulate these into actual plates.
• Divide each plate into a continental and oceanic part (either of which may be empty).
• Determine plate velocities based on adjacent plates (e.g. oceanic crust is pulled under continental crust).
• Generate features like mountain ranges and rift valleys along plate boundaries.
• Add simplex noise to make the rest of the terrain interesting as well.

As you can see at the end of the video, I took some effort to match the distribution of heights on the actual Earth. Not really necessary for the game, but a good check that my work made some kind of sense.

The video doesn’t show the flight_view or map_view tabs because they seem to be broken in the latest version, but here’s an old screenshot of the uplift map:

The map shows the boundaries of tectonic plates, their velocities, and the resulting uplift (mountain creation) along plate boundaries.

This project started in 2019 using Godot Engine version 3.1, and eventually got upgraded all the way to Godot 4.0. It used Rust and gdnative (later gdextension) for the high-performance bits. I abandoned it in January 2023.

Iteration 2: an actual game

In September 2020, a fortunate thing happened. It was the time of the 10th Alakajam, a small game jam community similar in format to Ludum Dare, that I’ve been involved with from the beginning. To celebrate the 10th instalment, there wasn’t just one theme, but three: maps, ships and chaos.

Guess who had been spending years thinking about a game involving at least maps and ships? To cover the chaos theme, I was hoping that procedural generation would help me out there. So I created a new repository, aroundtheworld2, and started work using Godot 3.2.

Making this game in a weekend was wildly ambitious, because my original plans were for a project that would take at least months to make. But I distilled it down to the essentials: you control a ship in a procedurally generated world, in which you have to find your way using maps. You can buy maps with gold, which is obtained by trading. You can also buy upgrades to sailing speed and view range. To add time pressure, you can only carry provisions for 10 in-game days of sailing; if you run out, you die. If you manage a complete circumnavigation and came back to your home port, you win. Somehow I pulled it off: it was a complete game!

The game came in 2nd place overall (out of 24 entries), and the feedback from fellow jammers was very positive, with several people suggesting I develop it further:

As a base for a longer solo project this seems very solid.

I know I will keep returning to play this game, and would love to see if it could be expanded post-jam

I see no reason why this could not be a paid-for game.

I would really like to see the post-jam version of this when it is released.

I was so happy to see that a full release is finally in the works, and I’ll be buying it for sure when you finish.

You can play this version online if you like. By sheer coincidence, random seed 0 gives you a good starting situation.

Iteration 3: Bevy, briefly

In April 2022, I started aroundtheworld3, still using Rust but this time using the Bevy engine. I think the reason was that I was dissatisfied with the quality of the Godot-Rust integration at the time, and I thought that a code-first approach would be a better fit for this project. I also may have been infatuated with the ECS (Entity-Component-System) architecture that Bevy uses.

Bevy was still fairly immature at that point, so it took a long time to figure out how to do anything. I liked Bevy and still do, but it just wasn’t ready yet to build this project on. I may also have been missing the ease of development that an editor like Godot brings, especially for building GUIs.

This incarnation was abandoned in the same month that it started, with only 622 lines of code written. All it did was show a sphere mapped with some simplex noise:

Iteration 4: Godot and C#

In April 2023, I seem to have decided to go with mature and trusted technology again. That meant the Godot engine. However, the Rust bindings still weren’t as great as they are today, and I knew that GDScript wouldn’t have the performance to do what I needed, so I opted for C# instead and started aroundtheworld4. Next to GDScript, this is the only other language that Godot has official support for, so I assumed it would be stable and solid. And it was!

The blog posts from part 1 all the way through part 21 were produced with this version, so I don’t need to say much about it here. Suffice it to say that I got some basic gameplay and trading going, in a 3D spherical world with a top-down camera.

However, I found that C# did not grow on me like I hoped it would. This is very subjective, and if I were working with it in a salaried job I wouldn’t even complain about it. However, if I’m going to sustain development on this game for months or years, it’s important that I keep up my motivation — and C# just tended to drain it. Because C# is a strongly typed language so “I could always refactor it easily later”, I racked up a fair bit of technical debt. Furthermore, working with a spherical world meant fighting the engine every step of the way. Moreover, the Godot-Rust bindings had improved a lot in the meantime.

All this eventually led to the decision to start over. I described my reasons more fully in part 22.

Iteration 5: back to Rust

That brings us to the project I am working on today, aroundtheworld5, started on 14 February 2025. This time, I decided to tackle the technically hard parts first, so I would have a solid foundation upon which to build the game.

This approach seems to be paying off: I now have a robust multithreaded implementation of LayerProcGen, some speedy noise functions, a procedural world generator whose output I can control to a sufficient degree, a floating origin to keep precision issues at bay, and on-the-fly chunk generation so we don’t have to generate the entire world in detail. Many of the procedural algorithms were ported over from the C# version, with some improvements along the way. Although there is always room for refactoring and cleanup, I still feel reasonably good about the codebase.

I could not have done any of this nearly so well without the experience of the previous implementations!

Where to next?

I also have more of a project plan than before, with the first three milestones fully mapped out. Milestone 1, “solid technical foundation” was achieved in November 2025. This allows me to focus now on Milestone 2, “core gameplay”. The aim is to implement all features from the Alakajam version, so we have a complete game loop:

• Camera controls — done.
• Ship controls — in progress. Still not decided whether it should be point-and-click or WASD.
• Buying and viewing maps — mostly done. The UI could use some improvement.
• Trading — not yet started.
• Provisions — not yet started.
• Some basic upgrades — not yet started.

Considering that the remaining items are things I implemented before in a single weekend, completion of this milestone shouldn’t take too much work.

I’m also cherry-picking some fun items from Milestone 3, “looking good”, to keep my motivation up. Good-looking visuals are also important to generate some early buzz about the game. Nobody gets excited about grey boxes! Here’s a teaser, showing some recent progress on waves and water rendering:

The long term

This one-year anniversary is also a good moment to reveal my plans for the full game, so I’ve set up a dedicated page for it. That text can eventually be used for a dedicated website, and onto the Steam page and other storefronts (I will definitely sell it on itch.io, and hopefully GOG as well if they’ll have me.). Go check it out!