I actually quite liked that simplicity in a strange way. It had a bit of charm to it. But with the rest of the game becoming more detailed, it was starting to stand out too much.

So I’ve now started bringing some micro voxel detail into the character as well.

The character model is more defined than before, and I’ve also changed the way heads work. There’s still only one head available at the moment, but the system now supports swapping them out. Long term, I want players to be able to choose from a range of different heads so characters can feel a bit more individual.

The bigger change, though, is actually the clothing and armour.

Previously, most clothing was basically just a texture placed over the character. It worked, but it didn’t really give any sense of physical clothing or equipment.

Now the clothing is built out as actual voxel geometry around the player. So things like armour, coats and other wearables have proper shape and volume rather than just being painted onto the body.

I’ve tried to keep that reasonably lightweight as well. At the moment, the player character is around 15,000 triangles at the high end, which I think is a fairly sensible place to be.

Performance is something I’m always keeping in mind, especially because I’m still targeting Steam Deck as a proper platform rather than treating it as an afterthought.

The character still looks a bit funny, and I think that’s okay.

I’m not trying to make Evolve look super realistic. It’s still a voxel game, and I want it to keep some of that character. The goal was really just to make the player feel like they belong in the same world as everything else, and I think it’s getting much closer now.

I’ve also done some work on how equipment stats are presented.

All of the clothing and armour already had values for things like armour, thermal insulation and rain protection, but previously I wasn’t really exposing that information to the player.

Now when you hover over an item in your inventory, you can actually see those values.

I’ve also added a lot more information to the character screen itself. There’s definitely quite a lot going on in there now, but it means you can properly see things like your total armour, how much thermal protection you currently have, and how well protected you are from rain.

That side of the UI will probably keep evolving, but it already makes the equipment system feel much more useful because you can actually understand what the things you’re wearing are doing.

I’d also been playing quite a lot of Valheim, and looking at how flexible their building system is made me a little bit jealous of what they had achieved. So I decided it was probably time to push mine further.

The core building blocks in Evolve are 0.5 metre voxels, which I really like because they give a nice level of detail. The downside is that placing everything one half metre block at a time can become quite cumbersome very quickly.

So one of the first things I changed was the way blocks can actually be placed. You can now drag out rows of blocks, and I’ve also added patterns through a new radial building menu.

For example, instead of placing every voxel individually, you can select a wall pattern made up of around 20 voxels and place a much larger section in one go. It keeps the underlying voxel system, but makes actually building something much faster.

I’ve also introduced what I’m calling pieces.

Pieces are things like posts, beams, stairs and smaller structural details. These sit outside of the normal voxel grid and can be positioned with much finer precision.

That means you can move a beam or post around within the space of a single voxel rather than everything being locked to half metre increments. It opens up a lot more possibilities for making buildings actually look interesting instead of everything feeling like it has been made from the same blocks.

I’ve also spent quite a bit of time improving alignment.

Previously, you had to look quite precisely at where you wanted something to go, and once I added pieces that became even more awkward. I now have a magnetic snapping system where nearby connection points are detected and pieces naturally snap into the position you probably intended.

It’s still something I’ll keep improving over time, but even at this stage it feels much nicer to use.

The radial menu has made quite a big difference as well. There are multiple pages for different building options, patterns and pieces, and I’ve tried to make sure it feels just as natural on a controller as it does with mouse and keyboard.

There’s still plenty I want to add to building, but it already feels much less like placing individual voxels and much more like an actual building system.

I always had it in my head that micro voxels would be the way to go eventually. The engine already supports them, and things like weapons and items are already built using micro voxels, so I decided to start moving the dinosaurs over as well.

At the moment I only have 11 dinosaurs in the game, but they’ve now all been rebuilt using micro voxels, and the difference is pretty huge. They still fit the voxel style of the game, but there’s a lot more shape and detail to them now.

Because of that extra detail, I’ve also had to start thinking more seriously about LODs. A Brachiosaurus, for example, is around 50,000 triangles at full detail, so over distance the models reduce in complexity to keep things sensible performance wise.

I’ve also been doing quite a bit of work on how the dinosaurs actually move.

One of the things I really didn’t like before was how they changed direction. If a dinosaur decided to attack something or turn around, the movement could feel really snappy. I had some smoothing in place, but it still looked wrong.

The new pathing works much more around proper curves and turning arcs. So a T-Rex, for example, can’t just turn on the spot. It has a much larger turning radius and has to properly move around to face something.

It sounds like quite a small thing, but it makes the dinosaurs feel a lot more physical and a lot less like AI agents just moving between points.

There’s still a lot of work to do on the AI side, and I’m definitely not where I want to be with it yet, but it’s starting to come together.

The other big thing I wanted to fix was foot sliding. Previously, the relationship between movement speed and animation just wasn’t quite right, so dinosaurs could look like they were skating across the terrain.

That’s now been fixed as well, and they feel much more planted to the ground.

Between the extra detail, the better turning behaviour and fixing the movement, the dinosaurs are finally starting to feel much closer to what I had in my head when I first started building them.

Water already existed in the previous version of the terrain, but moving from blocky terrain to smooth terrain created quite a few new problems.

The biggest one was that the water simulation itself is still voxel based. I wanted to keep that because it means water can actually react to changes in the world. So if you dig a trench away from a river, for example, the water can follow that new path rather than just being a flat visual effect sitting on top of the terrain.

The problem was getting voxel based water to actually sit nicely against smooth terrain.

With blocky terrain, that was much easier because everything naturally lined up. Once the terrain became smooth, the edges of rivers and lakes suddenly had to match much more organic shapes, and getting that to look right took quite a bit of work.

I’ve spent a lot of time improving that side of things, especially around river edges and how the water meets the terrain.

Underwater has had quite a bit of work as well and now feels a lot better than it did before. I’ve also been improving waterfalls. They’re still fairly limited at the moment, but they’re definitely heading in the right direction and I’ll keep working on them.

The important part for me is that the water simulation is still completely voxel based underneath.

So even though the terrain and river edges now look much smoother, the water can still behave like part of the world rather than just being decoration. You can change the terrain around it, create new routes for it to flow through, and eventually do much more interesting things with how water moves around the environment.

The main reason for it was actually pretty simple. During playtesting, I found that dinosaurs just didn’t path particularly well across blocky terrain. Small steps and sharp changes in height could cause problems, especially with the larger dinosaurs, and they could end up getting stuck on things that really shouldn’t have been an issue.

Moving to smooth terrain has helped a lot with that. Dinosaurs can move around the world much more naturally now, larger creatures have an easier time getting around, and overall it just feels better when you’re watching them move through the environment.

Visually, I think it’s been a nice upgrade as well. You can see dinosaurs much more clearly across hills and valleys, and the terrain feels a lot more natural.

The interesting part is that underneath, the terrain is still completely voxel based.

That means I haven’t lost the ability to actually modify the world. You can still dig into the ground, carve into hillsides and make your own caves. The difference now is that instead of everything looking like blocks have been removed, the terrain can form much smoother and more natural shapes.

I’ve also added sub-voxel precision, which gives much finer control when modifying terrain and means everything doesn’t have to line up perfectly to the voxel grid.

So although the terrain looks less traditionally voxel based now, all of that voxel data is still there underneath. For me, it’s ended up being a really nice middle ground. I get smoother terrain that works much better for dinosaurs, but I still keep the freedom to let players dig into and shape the world.

Reading back through my last journal entry, I think it probably came across as slightly more negative than I actually intended.

I talked quite a lot about not knowing exactly where Evolve was going, and about the fact that while the game was becoming playable, it still wasn't really hooking me.

I've had a couple of weeks away from it now to think.

And actually, I'm feeling really positive.

I have a much clearer idea of where I want to take both the engine and, more importantly, the game itself.

Giving the player a reason to care

One of the things I've spent quite a lot of time thinking about is what actually makes a game matter to the person playing it.

You can build a world.

You can put crafting in it.

You can give someone food to collect, a shelter to build and things to survive against.

But that doesn't automatically mean they will care about any of it.

There are definitely players who can thrive in a completely open sandbox and create their own purpose.

I don't think most players work like that.

I think most of us need to feel like we are moving towards something.

It doesn't necessarily need to be a quest marker telling you exactly what to do next, but there needs to be some reason to improve your character, build a better home, explore somewhere dangerous or survive another day.

Something that makes what you're doing now feel connected to what you want to do later.

That was the piece I felt Evolve was missing.

I think I've found it

Over the last couple of weeks I've come up with an idea for what that larger player loop could look like.

I'm deliberately not going to write too much about it yet.

Partly because I haven't built it.

And partly because I've already learned that something which sounds brilliant in my head can feel completely different once I'm actually playing it.

So I want to prove it first.

But for the first time, I can look at the systems I've already built and see how they might connect into something larger.

I can understand why a player might care about the world they're living in.

Why they would want to progress.

Why they might take a risk rather than simply staying somewhere safe forever.

And hopefully, why they might stop playing for the evening and still be thinking about what they want to do when they come back.

That last part is probably the important one.

The games I enjoy most are normally the ones where I'm still planning what I'm going to do next even when I'm not playing them.

That's what I want to try and create.

Whether this particular idea achieves that remains to be seen.

Now I need to actually build it.

But I wanted to write this mostly because the last post sounded like I was becoming negative about Evolve.

I'm not.

If anything, I'm more excited about where it's going than I was before.

I just needed to understand what I was actually trying to build.

Actually, it is probably closer to seven months now, but six-month update sounds better.

Things are going fairly well, so I thought it was worth doing a broader update on where the game actually stands today.

There is now something reasonably close to a playable game.

The world generates. Trees and foliage generate across it. There are caves, loose resources to collect, crafting, inventory, weather, a day and night cycle and the beginnings of the survival systems.

There are dinosaurs wandering around.

There is also now a proper map.

Quite a lot has happened.

The world is no longer infinite

One fairly fundamental thing has changed since I started.

Originally, Evolve had an infinite world.

Technically, it still can.

The terrain generation system is deterministic, so the world can simply continue generating as you travel. Given the same seed and coordinates, the server and every client generate exactly the same terrain.

Up until now I haven't even needed to cache generated terrain to disk. You could just keep travelling and new terrain would continue appearing ahead of you.

From a technical point of view, that works really well.

But after actually playing in it for a while, I've realised I'm not sure I actually like infinite worlds.

They sound brilliant.

In practice, I found there was something slightly strange about knowing that the world simply never ended.

There was no real sense of where I was within it.

If you travel north for a long time, there is always more north. There isn't really a shape to the world that you can learn or remember.

So I've changed it.

Evolve's worlds are now finite islands.

The generator still works in essentially the same way, and there isn't really a meaningful technical restriction on how large an island could be. If I wanted to generate something ridiculous like a thousand kilometres by a thousand kilometres, the underlying system could still do it.

But eventually you reach an ocean.

I think that gives the world something that was missing before.

It has a shape.

And because it has a shape, I can now generate a proper map of it.

You can look at the coastline, mountains, valleys and terrain and gradually build an understanding of where you actually are.

That feels much better to me than simply travelling forever.

There is now quite a lot to do

The terrain system itself is in a reasonably good place.

There is world generation, caves, trees and foliage.

I've also added deterministic placement for smaller world items.

Things like rocks and sticks can now be scattered naturally through the world, which starts giving the player the early resources needed for the Stone Age part of the game.

The first version of crafting is also working.

I've now got a fairly substantial Tab menu as well.

Pressing Tab opens what is becoming the main interface for most of the game's larger systems.

There is the inventory.

There is crafting.

There is a handbook.

There is the world map, including your position within it.

And there is an early character page.

The character page isn't doing much yet, but eventually I want it to become somewhere you can see information about your character and perhaps some statistics about what you've actually done.

Things like distance travelled are the sort of thing I'm experimenting with.

It is all still quite early, but the basic structure is there.

The weather is alive

The atmospheric side of the game is also now properly running.

There is a complete day and night cycle along with several different weather presets.

At the moment those are clear, cloudy, foggy, rain and storm.

Like most things in Evolve, the weather definitions are data-driven, so adding and modifying weather should eventually be relatively straightforward for both me and modders.

One thing I particularly like is the fog.

It isn't just a fixed amount of fog applied to the camera.

Fog actually moves across the world.

The fog simulation is deterministic as well, meaning the server and all connected players see the same fog moving through the same places.

You can actually watch banks of it travelling across the landscape.

It is a relatively small thing, but it has made a huge difference to the feeling of the world.

It works. But is it fun?

This is probably the more important part of the update.

The game is reaching a point where I can actually play it.

And I'm not sure it is hooking me yet.

The first day is quite enjoyable.

You arrive with nothing, start exploring, pick up resources and begin working out what you need to survive.

That part already has something.

The problem is what happens afterwards.

At the moment, Evolve doesn't really have a purpose.

There isn't anything pulling me into the next hour.

And that worries me much more than whether one particular technical system works.

I play quite a lot of survival games.

Valheim is probably one of my favourites. I play ARK. I play Rust.

They are all very different games, but with each of them I can normally explain why I want to keep playing.

There is always something just beyond what I'm currently doing.

A new biome.

A boss.

A better piece of equipment.

A base I want to finish.

Something another player has that I want.

Some reason to go somewhere dangerous.

Evolve doesn't really have that yet.

I can run around the world and enjoy being there, but I'm not currently thinking about it after I've stopped playing.

That is probably the next big problem I need to solve.

Dinosaurs are still difficult

I'm also still wrestling with navigation.

The voxel terrain makes AI considerably more complicated than I originally expected, particularly because the dinosaurs are all completely different sizes.

When you look at something like Minecraft or Vintage Story, a lot of the creatures roughly fit within the scale of the blocks they are navigating.

That makes an enormous amount of sense.

Evolve does not have that luxury.

A Compy is tiny.

A T-Rex is enormous.

A Brachiosaurus is ridiculous.

Trying to make all three convincingly navigate the same blocky terrain is difficult.

It can also create problems for the player.

Fighting something while standing on the edge of a voxel step can sometimes feel awkward. The dinosaur may be above you, below you or trying to move onto a piece of terrain that doesn't quite suit its body size.

It works.

I'm just not convinced it feels good enough yet.

This is something I'm still trying to understand rather than something I currently have a solution for.

Steam Deck is still the target

I also still haven't tested the game properly on a Steam Deck.

I have, however, tested it on an Xbox Ally X.

On low settings I'm currently getting somewhere around 35 FPS.

That's not terrible for where the game is in development, and there are still plenty of things I know I can optimise.

It does make me slightly nervous about the Steam Deck.

If I'm getting around 35 FPS on an Ally X, I'm fairly sure dropping the same build onto a Steam Deck today would not produce a particularly enjoyable result.

Probably something closer to 20 FPS.

So I'm not there yet.

But I'm still not giving up on it.

A lot of the heavy systems can scale. Draw distances can come down, foliage can be reduced, simulation distances can change and there are still plenty of areas where I haven't really started optimising yet.

I still think I can get there.

It is just going to require some work.

What happens next

So seven months in, Evolve is in a slightly strange place.

Technically, I'm quite happy.

Most of the foundations I originally wanted now exist.

I have a world.

It has weather, caves, vegetation and dinosaurs.

I can collect things, craft things and start surviving in it.

But I'm reaching the point where the question is becoming less about whether I can build the game and more about what the game actually is.

And I'm not completely sure yet.

I have some ideas.

The next thing I'm going to do is start trying some of them.

Some will probably work.

Some probably won't.

And if they don't, I'll remove them and try something else.

Hopefully the next time I write one of these I'll have a slightly clearer idea of where Evolve is going.

For now, though, I think figuring that out is probably the most important thing I can work on.

A T-Rex.

Up until this point, the Compy was really the only predator I had in the game. The Brachiosaurus was passive, so I wanted something at the complete opposite end of the scale. A very large predator that could actually hunt the player.

Getting it into the world went reasonably well.

It worked with the AI pathing system I had already built, and it could navigate around the voxel terrain and chase things as expected.

What I wasn't completely happy with was how it looked while doing it.

The problem with a creature the size of a T-Rex is that even relatively small changes in the terrain become very obvious across the length of its body. On steeper voxel slopes it could look strangely upright, almost as if the terrain underneath it wasn't really affecting it.

I've started compensating for that by allowing the body to tilt slightly as it moves up and down steeper inclines.

I've also added inverse kinematics to the dinosaurs so their feet can react more naturally to the ground underneath them rather than everything relying entirely on the animation.

There is still work to do here, but it already helps enormously with making such a large creature feel like it is actually standing in the world rather than simply moving across the top of it.

Then there was the slightly more important problem.

It couldn't bite you properly.

Technically, it could already hunt you.

It just bit with its feet.

The first strike system measured attack reach from origin to origin. For a voxel animal, that origin is effectively underneath the centre of the body.

That works surprisingly well until you create something with a head several metres away from its origin.

Standing directly in front of the T-Rex's mouth didn't necessarily mean you were in range.

Standing underneath it did.

The jaw itself also wasn't really doing anything. The model already had an attack pose, but the mouth was essentially scenery.

So I've changed how attacks work.

The bite now belongs to the jaw.

At the moment of impact, the hit test is performed from that part of the dinosaur's rig rather than from the centre of the creature. The dangerous part of a T-Rex is therefore finally the end with the teeth.

I've also added a proper two-stage bite animation.

During the windup the jaw opens, and then it snaps shut on the actual damage tick.

Range and stopping distance can also be configured per species. That means a T-Rex needs to get its head close enough to actually bite you rather than dealing damage from a body-length away.

I've also made predators track what they're attacking with their head while they hunt.

That sounds like a very small detail until you've watched a T-Rex chase you while staring at the floor.

Different animals will eventually attack in different ways. A tail strike is a very different problem to a bite, and something with horns will need another solution again.

But for a predator whose main weapon is supposed to be its mouth, it seemed fairly important that the mouth actually did the work.

What's in the world now is that network: long water cutting with the land, falling where the ground steps down, and meeting the ocean instead of stopping inland. Rivers show on the world map too, so finding one is a navigation problem rather than a lucky walk.

The water itself moves. Step in and you drift downstream with the current. Loose objects are meant to take that same ride: a log should be able to find the sea on its own. That's the groundwork for rafts and boats, not a feature that exists yet.

The waterfalls are already real as geometry. They still look like stacked cubes, though. The falling-water shader isn't doing its job yet, and that's the next question rather than a finished look.

Not just for me.

For anyone who eventually wants to mod it.

That has influenced quite a few of the decisions I've made about how the game itself is structured.

The main one is that almost everything in Evolve is data-driven.

Everything starts as data

Rather than hard-coding every item, block or creature directly into the game, most of that information comes from JSON files.

Items are defined in JSON.

Blocks are defined in JSON.

Recipes are defined in JSON.

Loot tables are defined in JSON.

Even things like dinosaurs and other world entities are built around the same idea.

The game reads the data and uses it to construct whatever that thing is supposed to be.

That makes things considerably easier for me while developing the game, because adding a new item doesn't necessarily mean going back into the code and creating an entirely new implementation.

But it should also make things much easier for modders later.

If someone wants to add a new block, for example, ideally that should mostly mean defining what that block is, what it looks like and how it behaves.

The engine should handle the rest.

That is the direction I'm trying to take with pretty much everything.

Designing around modding now

It would be very easy to build the game first and then worry about modding later.

The problem is that by then a lot of the decisions that make modding easy or difficult have already been made.

So I'm trying to think about it now.

That means keeping systems generic where I can and avoiding assumptions that only make sense for the content I personally intend to create.

Dinosaurs are a good example.

I obviously have a roster of dinosaurs that I want to add to Evolve, but I don't want the creature system to fundamentally know what a Brachiosaurus or a Compy is.

It should understand a creature described by data.

The same should eventually apply to most of the content in the game.

That means, at least in theory, there is nothing particularly special about the content that ships with Evolve compared with something added afterwards by a mod.

There will obviously be limits to that, but that is the goal.

Lua later

JSON works very well for describing things.

It is less useful when you want something to actually do something unusual.

For that, I am planning to add scripting support using MoonSharp, which is a Lua interpreter for .NET.

I haven't actually built the scripting side yet, but I have tried to make decisions around the current systems that won't prevent me adding it later.

The idea is that JSON handles the data, while Lua could eventually handle more complicated custom behaviour.

That should give modders quite a lot of freedom without requiring them to actually modify or compile the game itself.

Exactly how much of Evolve will eventually be exposed through Lua is something I haven't decided yet.

It is very easy to say that everything should be moddable, but every extra thing you expose is also something that needs to be supported and kept working as the game changes.

So I'll probably grow that side of things gradually.

Distribution is a problem for later

The part I haven't really thought too deeply about yet is how mods will actually be distributed.

Steam Workshop would obviously be one possibility.

There are other ways of doing it as well.

There are also questions around how multiplayer servers handle mods, how clients discover what they need to download and how different versions of mods are managed.

Those are all real problems, but they're not problems I need to solve today.

Right now I care much more about making sure that when I eventually get to that point, the game is actually capable of being modded in the first place.

Changing how mods are downloaded later is relatively easy.

Trying to retrofit a modding system into a game where everything has been hard-coded for years is probably not.

So for now, that is the important part.

Modding isn't something I'm planning to bolt onto Evolve at the end.

I'm trying to make sure the foundations for it are there from the beginning.

I could probably have left this much later.

There are still plenty of systems to build before Evolve is really a game, but I had one fairly big concern that I wanted to answer early.

Most voxel games do not have enormous creatures walking around in them.

And some dinosaurs are enormous.

A Brachiosaurus moving through a voxel world is a very different problem to a player walking around in one.

How does something that large move across the terrain?

What happens when it reaches a ledge?

How does it path around cliffs?

Does it look ridiculous walking across one metre blocks?

I decided it was probably worth finding out now rather than discovering much later that my terrain and creature systems fundamentally did not work together.

Building the first dinosaurs

So I started putting together the first voxel dinosaurs.

At the moment they are intentionally quite simple.

Very blocky models, fairly basic texturing and nowhere near the amount of detail I eventually want them to have.

I expect I will come back to the dinosaurs visually quite a few times as the game develops.

For now, I mostly need them to exist.

That lets me start putting different body sizes into the world and work out how they actually behave against the terrain.

I've put together an initial roster of dinosaurs that I'd eventually like to get into the game, but so far I've only brought three of them properly into the world.

A Compy.

A Brachiosaurus.

And a Pteranodon.

That gives me three quite different problems to solve.

The Compy is tiny and needs to deal with relatively enormous steps compared with its body size.

The Brachiosaurus is at the opposite end of the scale and spans a huge amount of voxel terrain while it moves.

And then the Pteranodon gives me something that doesn't really care about the terrain at all.

It seemed like a reasonably good set to start with.

Everything comes from data

One thing I am trying to stick to throughout Evolve is making the game as data-driven as possible.

Dinosaurs are no exception.

The model, configuration and behaviour of a dinosaur should ultimately come from data rather than being hard-coded into the game.

The same approach will apply to world items and quite a few other systems.

Part of the reason for that is simply development speed. It means I can create something new without having to write a completely new system every time.

But the bigger reason is modding.

Long term, I want players to be able to add their own things to Evolve.

That could mean changing an existing dinosaur, adding a new one or creating something completely different.

I'm not at the stage where any of that is exposed properly yet, but I'm trying to build the foundations so that it can be.

Ideally, creating new content should eventually be mostly a case of providing the data and assets rather than needing to change the game itself.

Getting them around the world

The more interesting problem has been AI.

A traditional nav mesh isn't really an option for Evolve.

The entire world is destructible.

A player can dig through terrain, build a wall, remove a wall or completely change the route that a creature would previously have taken.

There isn't really a static world that I can bake navigation information into.

So instead I'm working towards an on-demand pathing and steering system.

The current idea is that creatures make navigation decisions at a relatively low frequency, probably somewhere around four times per second, and then steering and movement smooth everything between those updates.

Exactly where that ends up will depend heavily on performance once there are lots of creatures in the world.

For now, though, it is working surprisingly well.

I've got Compies running around the terrain and reacting to the voxel landscape.

The first version looked slightly ridiculous because every half or one metre change in height made them visibly snap upwards or downwards.

So I've had to add quite a lot of smoothing to make movement across the blocks look natural.

That already makes an enormous difference.

Losing Compies in the grass

There are also some problems I didn't really think about until I actually put creatures into the world.

Compies are very small.

My grass is not.

They therefore have a habit of disappearing.

From a realism point of view you could argue that this is exactly what should happen. A tiny dinosaur running through long grass probably shouldn't be particularly easy to see.

From the player's point of view, I'm not quite as convinced.

There is probably a point where realism stops being interesting and just becomes annoying.

I don't know what I'll do with that yet.

It might mean changing how the grass reacts around small creatures, changing how visible the dinosaurs are or simply accepting that sometimes something small is going to disappear into the undergrowth.

It is another one of those things I'll probably only understand properly once there is more gameplay around it.

So far, so good

For now, I'm mostly happy that the basic idea works.

Small creatures can move around the terrain.

Very large creatures can exist within it without immediately looking completely wrong.

Flying creatures give me a completely different navigation problem to start experimenting with.

There is still a huge amount of work to do on AI, particularly once dinosaurs need to do more than simply move around.

Eventually they need behaviours, needs, reactions to the player, reactions to each other and some understanding of the world around them.

But the first step was really just answering the question of whether dinosaurs of completely different scales could live in this voxel world at all.

So far, I think they can.

I'll put the current dinosaur roster below. Most of them aren't actually in the game yet, but it should give a fairly good idea of where I'm hoping to take things.

One thing I am learning is just how much development time ends up being spent on refinement.

The first version of the world generator was actually quite quick to build. Getting mountains, valleys and generally believable terrain appearing was not especially difficult. The problem only became obvious once I started spending more time actually playing in it.

There was too much similarity between the features.

So I started adding more variation. Cliffs, sharper ridges, overhangs and generally more interesting terrain.

The problem is that it is very easy to confuse more detail with better terrain.

What I eventually ended up creating was vast quantities of noise.

This hillside is a pretty good example. In a screenshot, you could probably argue that it looks interesting. There is plenty going on, lots of shape and plenty of variation.

It is also absolutely horrible to walk across.

Evolve needs a world that looks worth crossing and that you can actually cross. The same constraint applies to the dinosaurs. If a player can only get over a slope by hopping every half metre, a herd cannot path it particularly well either.

A one metre riser is a step. Two metres is a wall.

This slope is the worst of both.

It never becomes a cliff you naturally go around, and it never becomes ground you can simply walk across. It is just stairs all the way down, with a tuft of grass on every tread.

That is the balance I have been chasing in the generator.

Dramatic terrain is fine. A mountain you remember is fine. Cliffs and overhangs are absolutely things I want in the world.

What I cannot have is terrain that is interesting in a screenshot but unpleasant as a place to actually play.

Plains need to be places you enjoy being in. Mountain ranges need valleys between them that you can naturally follow. Cliffs should read as cliffs, rather than every metre of the map turning into another step.

There has already been quite a bit of work towards that.

Valley floors. Limits on how much of the map a single massif is allowed to consume. Checks during world creation that use similar walk and roam tests to the ones the player and creatures actually depend on. Areas of terrain that remain on the finer half-metre resolution so that everything does not simply become one-metre terraces.

On paper, the amount of land that a dinosaur can actually roam across has improved considerably.

This screenshot is the leftover problem.

The landscape can be working correctly at a large scale and still be completely wrong in places like this.

World generation is probably going to be one of those systems that I never really consider finished. Every time I spend more time playing in the world, I notice another pattern, another awkward slope or another area that feels too repetitive.

And I think that is fine.

I will keep coming back to it and improving it.

The danger is spending forever doing that.

There are always more terrain features I could add and always another generation rule I could tweak, but at some point I also need to keep pushing forward and actually build the rest of the game.

For now, I think the world generation is good enough to continue.

The next improvement is not adding even more features on top. It is teaching the generator when a slope should flatten into something you can comfortably walk across, and when it should commit to becoming a proper face that you naturally go around.

Then I need to leave it alone for a while and build something else.

The biggest lesson is probably that smaller voxels are not always better.

When I first started thinking about the game, I seriously considered using 0.25 metre voxels.

On paper, that sounds great.

You get loads of detail, buildings can be much more precise and the world should theoretically look less blocky.

The problem is the amount of data.

A normal one metre voxel contains 64 individual 0.25 metre voxels. You have four voxels along each axis, so 4 × 4 × 4 gives you 64 blocks occupying the same volume.

That is an enormous amount of data once you start talking about an entire world.

Even with ECS and DOTS, I very quickly came to the conclusion that trying to build the whole game around 0.25 metre voxels just isn't realistic.

So I've settled on 0.5 metres.

And actually, I'm really happy with that decision.

For building, 0.5 metres feels really nice. It gives enough precision that you can create much more interesting structures than you could with one metre blocks, without creating a completely ridiculous amount of voxel data.

So that part worked exactly as I'd hoped.

The terrain did not.

Apparently voxel games know what they're doing

One of the things I assumed at the start was that smaller voxels would automatically make terrain look better.

Turns out that isn't true at all.

If you generate a mountain entirely out of 0.5 metre blocks, there is just too much detail.

Every slope contains twice as many steps. Every ridge has more edges. Every little change in elevation becomes visible.

When you look out across a large landscape, instead of getting this nice coherent mountain shape, you get visual noise.

It looks awful.

It actually made me start thinking that perhaps all of these other voxel games know what they're talking about and I don't have a clue.

There is something psychologically quite pleasant about larger voxels when you're looking across terrain. Your brain seems to understand the shapes much more easily.

The other issue is movement.

With 0.5 metre terrain you end up with steps everywhere.

You can obviously make the player automatically climb over them, but you still feel all of those tiny changes in elevation as you move around the world.

It just doesn't feel particularly nice.

And considering one of my main goals is to have huge mountain ranges and large natural features, that was becoming a fairly big problem.

The compromise

I've ended up with what I think is a good compromise.

Internally, the world still uses 0.5 metre voxels.

But the natural terrain generates at one metre resolution.

So when you're standing looking across the world, the terrain essentially looks like it is made from one metre voxels.

If you then start hacking into the terrain, you're actually interacting with the underlying 0.5 metre voxels.

That means I still get the precision I wanted for digging, building and manipulating the world, without having the entire landscape covered in tiny blocks.

At the moment, this feels much better.

It has definitely been one of those things where actually building it taught me far more than thinking about it ever could.

The world is getting big

Performance so far has actually been really encouraging.

At the moment I'm drawing full voxel terrain out to around 512 metres from the player.

Beyond that I switch over to a much cheaper clipmap representation.

That allows me to show terrain several kilometres into the distance. At the moment I'm around four kilometres, which is already more than I really need because by that point atmospheric fog will obscure most of it anyway.

So I'm fairly happy with where the terrain system is.

World generation is working.

Terrain streaming is working.

The texturing system is working.

I can run around the world with the player character and, importantly, it is starting to actually feel like somewhere rather than just a collection of technical systems.

There is obviously still a lot to do, but the underlying direction now feels much clearer.

Trees and foliage

Once the terrain was in a reasonable state, the next big thing I started looking at was vegetation.

Trees are slightly interesting because they're split between two systems.

The trunks themselves are true voxels.

They use the same underlying voxel system as the terrain and are currently built using the same 0.5 metre resolution.

Leaves and grass are handled separately through the foliage system.

That system has turned out to be very performant.

At the moment I'm able to draw quite large quantities of foliage out to around 96 metres from the player without performance becoming a major problem.

That includes both grass across the terrain and the leaves on trees.

My current development machine uses an RTX 3080, so it's certainly not a low-end GPU, but I'm deliberately trying not to design everything around extremely high-end hardware.

One of my slightly ambitious goals is still Steam Deck support.

I haven't actually tried the game on a Steam Deck yet, so I may regret writing this later, but looking at the profiler I'm still reasonably confident that I can get it running.

A lot will come down to how aggressively I reduce things like draw distance, foliage distance and simulation range.

But so far, I haven't seen anything that makes me think it's impossible.

Making the atmosphere

I've also started working more on the atmosphere of the world.

That means clouds, fog, weather and generally all of the volumetric effects that hopefully make the world feel a little less like a collection of cubes.

I'm using Unity's Universal Render Pipeline rather than HDRP.

The main reason for that is scalability. URP gives me a much better chance of targeting lower-end hardware and hopefully eventually handheld devices.

The downside is that you don't really get all of the volumetric systems I want out of the box.

So I've ended up building most of them myself.

That has been somewhat time-consuming.

I'm definitely a developer rather than a graphics artist, so almost everything I'm doing has to be approached from the code side first.

Things like clouds and atmospheric scattering are therefore another fairly large learning curve for me.

But they're starting to work.

And combining those more realistic skies, fog and lighting with the voxel terrain is beginning to produce something quite close to what I originally had in my head.

Three months in

Overall, I think things are going pretty well.

The basic world exists.

I can generate it, stream it, texture it, walk around it and see several kilometres into the distance.

Trees and foliage are working.

The first versions of the weather and volumetric systems are working.

And, perhaps more importantly, I've already found a few assumptions I made at the beginning that turned out to be completely wrong.

I think that's probably going to happen quite a lot.

Progress is maybe slightly slower than I imagined when I originally wrote down the plan, but not dramatically so.

Three months in, I'm still roughly where I hoped I would be.

And for the first time, it's starting to look less like an engine and a little bit more like the beginnings of a game.

That sounds worse than it probably is. Most of that time has really been spent learning. I’ve built lots of systems, started lots of projects, thrown plenty of things away and gradually learned more and more about how Unity actually works.

Everything I’ve made so far has been in Unity, and pretty much every project has eventually run into the same problem.

I like big worlds.

Survival games have always been the games I enjoy the most, and my dream has always been to make something that feels genuinely large. Somewhere you can head in a direction and actually feel like you’re travelling, rather than just moving between different parts of a relatively small map.

The problem is that doing that in Unity isn’t particularly straightforward.

Unity traditionally uses 32-bit floating point positions, and once you start getting several kilometres away from the world origin you eventually start running into precision problems. Things begin to jitter and behave strangely, and when you then add networking into the mix it becomes even more complicated.

There are ways around it, such as moving the world around the player with a floating origin system, but doing that in a multiplayer game adds another layer of complexity.

Most of the things I’ve built previously have therefore ended up being relatively small scale.

With Evolve, I want to try something different.

Building it differently

I’ve decided to build Evolve around Unity’s ECS and DOTS systems.

That is partly because of performance. A voxel world potentially contains an enormous amount of data, and ECS is very good at processing huge numbers of relatively simple things very quickly.

But it also gives me much more control over how the world itself is represented.

The long term goal is to build a world that can be much larger than anything I’ve attempted before, while still supporting networking and the amount of simulation I want to run in the background.

A lot of people would probably say that if large worlds are so important to me, I should just use Unreal.

And there is definitely an argument for that. Unreal uses 64-bit coordinates for its large world systems and has a lot of technology already built around enormous environments.

The problem is that I’ve spent years learning Unity.

Starting again with an entirely different engine, editor, networking stack and programming environment just doesn’t really appeal to me. Unity is also an incredibly capable engine, especially once you start digging into DOTS.

The downside is that DOTS has a fairly brutal learning curve.

So a large part of the first phase of Evolve is really going to be building the technology underneath the game.

A voxel survival game

The basic idea for Evolve is a hardcore survival game set in a world inhabited by dinosaurs.

The world itself will be voxel based, but I don’t want to use particularly large voxels.

Minecraft, for comparison, uses blocks that are roughly one metre across.

At the moment I’m thinking Evolve will use either 0.5 metre or possibly even 0.25 metre voxels.

That obviously means significantly more data, but I think the smaller scale could make a huge difference to what can be built with them.

Buildings should be able to have much more detail, terrain should feel less blocky and there should generally be more freedom to shape the world.

I also suspect I’ll eventually end up using micro-voxels for certain things where even more detail is useful.

Exactly where the balance ends up between performance and detail is something I’m going to have to discover as I build it.

A slightly strange visual style

Visually, I want to try something that might be slightly unusual.

The world itself is going to be stylised because it is made from voxels, but I don’t necessarily want everything around it to be stylised in the same way.

I want realistic clouds.

I want proper fog.

I want good lighting, storms, rain and an atmosphere that can sometimes feel almost realistic.

That might end up being a strange combination.

Traditionally voxel games tend to lean heavily into the voxel style. The terrain is voxel, the characters are voxel, the clouds are voxel and everything fits together nicely.

I want to experiment with mixing the two.

There are actually plenty of Minecraft shader packs and mods which do something similar. They take this extremely blocky world and put realistic skies, lighting and weather around it, and somehow it works.

Whether I can make that work for Evolve remains to be seen.

Making the world feel alive

Probably the biggest part of the vision is the simulation itself.

I don’t just want survival to mean watching a hunger bar slowly go down.

I want weather.

I want seasons.

I want temperature to matter.

I want crops to grow differently depending on the time of year and the conditions they’re growing in.

I want rain, fog, wind and changing weather patterns to actually affect how you play.

If winter is approaching, I want there to be a reason to prepare for it.

Then on top of all of that are the dinosaurs.

The aim is for the world to feel like a place you are trying to survive in, rather than a world that exists purely to give the player things to fight.

Where the game goes after that initial survival experience is still a little bit up for debate.

I have plenty of ideas about progression and what players might eventually work towards, but I don’t want to design too much of that before I actually know whether the underlying survival game is fun.

My plan is to build the world first.

Build the terrain.

Build the simulation.

Build the basic survival mechanics.

Then play it.

Once I can actually spend time in the world, I think it will become much clearer what the longer term progression loop should look like.

Multiplayer from the beginning

Another thing that is very important to me is multiplayer.

I enjoy survival games far more when I’m playing with other people, and Evolve is going to be built as a networked game from the ground up.

Technically I expect you’ll be able to play it alone, but I think the game will ultimately be at its best with friends.

I’m also planning to use dedicated servers rather than peer-to-peer networking.

There are several reasons for that, but one of the biggest is simply that I want the server to be capable of doing a lot of the heavy lifting.

If the world contains large amounts of simulation, AI, weather, animals and potentially lots of players, having a dedicated server gives me somewhere authoritative to process all of that without relying entirely on one player’s PC.

PvP, but not Rust

I also want PvP to exist.

Not because I want to make another Rust, but because I like the risk created by knowing another player might be out there.

You might be hunting.

You might be gathering resources.

You might be travelling somewhere with something valuable.

The fact that another player could interfere with that adds another layer of tension to the world.

At the same time, I want PvP to be completely optional.

There is a fairly common belief that PvE and PvP players cannot coexist in the same game and that you have to choose one or the other.

I’m not convinced that is necessarily true.

I think a lot depends on how PvP is designed.

In particular, I’m far more interested in encounters between players out in the world than I am in making a game centred around destroying somebody’s base while they are offline.

Base raiding creates an entirely different style of game.

I want PvP to create risk without necessarily becoming the entire reason the game exists.

How that balance actually works is something I’ll have to experiment with much later.

Steam Deck?

One slightly ridiculous goal I’d also really like to achieve is Steam Deck support.

My wife has a Steam Deck and absolutely loves it, and I think being able to play Evolve on a handheld would be brilliant.

Whether that is remotely realistic for a game with an enormous voxel world, dinosaurs, weather and lots of simulation remains to be seen.

But this is another reason I’m excited about using ECS and DOTS.

If I can make the underlying systems efficient enough, then theoretically I can start scaling things like draw distance and simulation distance down depending on the hardware.

Maybe a desktop PC can see kilometres into the distance while a Steam Deck sees considerably less.

I genuinely think it might be possible.

We’ll see.

The plan

For now, almost all of the work is going to be on the underlying engine.

Terrain generation, voxel storage, networking, world streaming and all of the things that need to exist before there is really much of a game.

I’m giving myself somewhere around three to six months to get the core world technology into a state where I can confidently say it works.

Hopefully within around six months I’ll have something resembling a prototype where I can actually run around the world.

Then perhaps another few months to start adding some real survival mechanics and an actual gameplay loop.

And, if everything goes particularly well, I’d love to have something approaching Early Access within roughly twelve months.

Those are very ambitious timelines.

Considering I’ve spent the last five years starting games and never actually finishing one, there is every possibility I’ll look back at this post in a year and laugh at them.

But that’s the vision.

A huge voxel world.

Dinosaurs.

Seasons, weather and survival systems that actually matter.

A world you can explore with friends, where another player might be just as dangerous as whatever is hiding in the trees.

Now I just need to build it.