After participating in a number of weekend game jams over the past few years, I happened to hear about one that spanned a longer time period – two weeks – and although it was a smaller jam hosted on rather than a large community like Ludum Dare, it seemed to be getting a fair amount of interest. Intriguingly, rather than having a theme voting period and then revealing that theme at the start of the jam, it made the theme known well in advance: “create an unpredictable and unexpected game.”

It was called Unexpected Jam and was scheduled to run from August 29th to September 14th, 2020. I thought it would be fun to give it a try, and right off the bat, that theme seemed to lend itself well to doing something with procedural generation. Could I make something that might produce results “unexpected” even to myself?


Years ago, I stumbled upon this really cool Gene Pool game (or really more of a simulator) where randomly-generated “Swimbot” critters compete for food and mates, and evolve into more efficient forms. I remember being fascinated by it, and would let it run for hours at a time to see what would happen.

For purposes of this blog post, I revisted the current version of this Gene Pool game and grabbed a screenshot:

An example of the Gene Pool simulator at the very beginning, with a bunch of random creatures.
An example of the Gene Pool simulator at the very beginning, with a bunch of random creatures.

Partially inspired by this and partially just out of interest in biology and such, I’ve had the idea in the back of my mind for a long time that it would be really fun to play around with simulated evolved creatures of some sort. And the concept of creatures mutating and evolving in potentially unpredictable ways seemed like a good fit for the “unexpected” theme.

In the lead up to the game jam, I searched around for more examples of this type of thing, and found a few others:

  • The Fittest 2 - A fairly simple evolution simulator where “fitness” is measured based on how far the creature can run. The one that made it the farthest proceeds to the next generation, with small mutations, and eventually a faster creature emerges.

  • Evolution Simulator - In each generation, 1000 creatures are tested for speed, and only 500 of those are allowed to breed. This one has the interesting twist that it isn’t strictly the 500 fastest – due to random luck, a few fast ones get eaten and a few slow ones survive.

In the past, I’ve found that keeping the scope manageable is one of the biggest challenges going into a game jam, and it was a little hard to guage whether some kind of creature evolution simulator game could be plausibly “game jam sized” – even for a longer two-week jam rather than a single weekend one. But even so, I started brainstorming a plan.

The Plan

In the interest of keeping things simple, my basic idea was that the player would be presented with an assortment of creatures, and they could pick two to “breed” – the next generation would then be based on the “genetic” features of those selected creatures, with some random “mutations” thrown in.

Unlike some of the other evolution simulator examples, where “fitness” was measured in terms of how fast the creature could move or how efficiently it could find food, this game would be 100% based on the player’s choice – which would presumably be based on which creatures they found the most visually interesting.

Another part of my idea was to represent DNA as a string of “base pairs”, using only the letters A, C, G, and T, inspired by real-life DNA. Numeric values could be extracted from that string to set various properties of the critters:

A concept for how to translate a string of ‘DNA’ into numbers on a hex scale.
A concept for how to translate base pairs from a string of 'DNA' into hexidecimal values.

The idea was that when breeding, the creatures would inherit some of the DNA pairs from each parent. It would also play into how mutations work – there would be standard “point mutations”, where a letter is replaced with a different letter. But there could also be “insertion” mutations, where new characters are inserted somewhere in the string, making the DNA actually longer, and the creature more complex in turn (adding additional limbs, etc.)

As you might guess, this is starting to get into that “unreasonably large scope” situation that is always my downfall in game jams – there would definitely be a limit to how much complexity would be feasible to create in the span of two weeks.

The Development Process

After all that scheming about DNA and ever-increasing complexity, when the game jam actually started, I spent the first few days just playing around with shaders in Godot Engine. I had never really done anything with shaders before, but wanted the ability to render a 2D creature comprised of multiple separate polygons, with a single solid outline around the whole thing. Here’s what this looked like in the early phases after getting it working:

An image showing an assortment of simple creatures comprised of multiple polygons, with a solid shader outline.
Polygon creatures with a solid shader outline.

In the above image, the “head” and each of the two “legs” are a separate Polygon2D in Godot Engine, with the outline shader applied to one of the parent nodes. With this approach I figured it would be easy to add all kinds of additional limbs and such, and still have it look like a single cohesive critter.

From there, I set out to carry out the rest of the plan relating to DNA and inheritance and mutations – although this is where I crashed into the wall of limited time + maybe slightly over-ambitious scope. Color, size, and limb placement was about all I managed to vary in the critters.

I also learned that a two-week game jam has a very different feel from a weekend one. That burst of intensely-focused “spend every available moment on it” effort, with the goal to finish something in two days, isn’t really sustainable over a longer time period. Plus, the fact that it spanned over the work week meant that there were a few points during the jam when I didn’t make any progress for days at a time – which wasn’t great for keeping the momentum going.

But in the end, I did manage to finish and submit something functional to the jam – Here’s what the final version looked like:

Animated gif showing a game where you selectively breed mutating colorful creatures.
The final gameplay in action.

The jam submission page is here and the game is available to play on here for anyone interested in checking it out. While I don’t think there ended up being enough complexity there to produce anything truly unexpected, the mutations that show up in the next generation can be fairly unpredictable, which is at least sort of approaching the ballpark of what I was aiming for. But overall, it’s just a fun colorful little toy to endlessly click on with no ending or win/lose conditions.

Results & Feedback

In the end, my submission ranked 83rd out of 179 entries, a middle-of-the road score that’s pretty typical for my game jam entries.

A screenshot showing the ratings received from the game jam submission.
The final ratings received in the game jam.

Since it was a smaller jam, there were fewer total comments compared to what I’ve typically gotten in something like Ludum Dare, but here were the common themes:

  • Cute / cool / fun / nice / enjoyable / okay (6)
  • Needs more variation / differences in the creatures (2)
  • Needs some relaxing background music (1)
  • Needs the ability to unselect creatures (1)
  • Not very unexpected (1)

Of these, adding background music is probably the biggest one that I should have addressed, in retrospect, since it’s a fairly small effort that can have a big impact. I hadn’t really thought about the UI aspect of being able to unselect creatures, but it makes a lot of sense. And the stuff about needing more variation I definitely agree with (as discussed earlier in this post).


And that concludes yet another game jam postmortem on this little dev blog! I’m a little torn on whether to pursue longer (2+ week) game jams in the future, rather than sticking to weekend ones. In theory, a slightly longer jam seems like it has the potential to make something a little more ambitious, but in pratice that didn’t really seem to work out for me this time around due to the momentum / sustainability problem. So, that’s something I’ll have to consider going forward.

But either way, I don’t have any specific game jams planned on my horizon in the near future – my main focus right now is still to release a full cross-platform mobile game (for iOS + Android). And right now, that’s been taking the form of migrating my one existing released iOS game from SpriteKit (proprietary and Apple-only) to Godot Engine (cross-platform and open source), which I think will be an invaluable experience for building up to more complex Godot games.

I hope to have a dev blog update soon about how that process is going so far. In the meantime, feel free to sign up for the email mailing list for any big announcements, or check out my Twitter for smaller updates. Thanks for reading!