I am building Evolve as a solo developer, one connected system at a time. These are working captures rather than trailer shots. Each one records a question, an experiment, or a moment when the engine began to feel more like a world.
Screenshots shown in development order · Everything remains work in progress
My first greedy meshing pass found the voxels fine. It also found almost every edge case going in section boundaries, face visibility, and winding, which is most of what you're looking at here. Ugly as it is, it proved the pipeline worked end to end: terrain data really could get from a 32 cubed voxel section to a rendered mesh.
Once winding was sorted out, hills and valleys actually started looking like hills and valleys. The bright, ugly colours aren't a style choice, they're so I can't mistake one block type for another while I'm still debugging the generator. Still nowhere close to a world, but for the first time it had a horizon.
This plotting window is where the item model pipeline started. Handheld objects get their own smaller voxel scale instead of the half metre terrain grid, so something like a stone point can carry real detail without dragging up the resolution of the whole world. Those text defined models are meshed at runtime now, shared by held items, drops, and world props.
There were barely any real items to put in this inventory yet, but I needed to know how crafting, equipment, and storage sat next to each other before there were. It's dense and unstyled, but the layout logic here is basically what still runs the current UI Toolkit menu. Working with empty slots actually helped, since there was nothing for a bad structure to hide behind.
Trees started as voxel stamps placed by the same deterministic worldgen pass as the ground under them, so it's the same seed and the same forest for every player, and trunks you can actually edit. Full block leaves made this first canopy way too heavy. Still, it proved the point I cared about: the forest could be built from the world instead of dropped on top of it as scenery.
Colour here is a debugging tool first, but it's also roughly where the palette started to take a real direction. Loud, flat values still make it obvious where soil, stone, sand, and water change, so a misplaced layer or a sharp biome edge jumps out immediately. Even at this diagnostic stage the values were already leaning dark and moody rather than bright and saturated, closer to a survival game than blocky Minecraft tones. Real textures came later, once I actually trusted what the columns underneath were doing.
A geometry clipmap gets the world a horizon without storing real voxels for kilometres. My first version used sloped quads for the far cells though. Efficient, and completely wrong for how Evolve is supposed to look. The fix keeps the same fixed cost rings but builds them from flat tops and vertical risers, so distant mountains still read as blocks instead of a smoothed off hill.
URP doesn't give you the atmosphere I wanted out of the box, so this is the first real attempt at building a custom stack on top of it. The fog here is blunt and turns the forest into a grey wall, but it taught me how much height, distance, and sunlight actually do for scale. What's running now combines analytic fog with an optional ray marched volume and wind driven fog banks.
The authoritative world clock existed well before the sky had anything interesting to do with it. Time was already advancing from fixed simulation ticks and driving the daylight scalar here, even though the clouds are still flat layers over a plain backdrop. Building the clock first meant the sun, moon, stars, weather, and seasons that came later all share one source of time.
These early dinosaurs are studies in proportion, joint placement, and silhouette, nothing else. Each one is assembled from text defined voxel parts with its own data built rig, not an imported skinned model. Textures and species specific movement were still a long way off, but the decision was already made: wildlife belongs to the same constructed world as the terrain and the trees.
Swapping solid leaf cubes for individual leaf blocks let light and fog into the canopy for the first time. It's a halfway point though, still stuck on the half metre grid and still too chunky up close. It led to the current split anyway: voxel trunks with three dimensional leaf card clusters nearby, whole tree billboards carrying the forest into the distance.
This clothing test was never really about fashion, it was about who owns the data. Equipment needs to show up on the paperdoll, change how the character actually looks, and eventually feed warmth, rain protection, and armour off one item definition. The art here is a placeholder, but the path from inventory slot to a replicated character overlay was starting to hold together.
None of these were just a tuning problem. The weapon, hands, and camera were being described in three competing coordinate frames, so fixing one angle would just break something else. It took three failed attempts to actually see the fix: place the weapon first, then solve each arm toward its own independent grip target.
The eventual fix is a blend, not a single pose. The bow runs on forward kinematics while it's carried, so the arms stay part of the normal walking gait, then crosses over to two bone inverse kinematics as it's drawn. Weapon, arrow rest, hands, and elbows all follow the player's view now, and first and third person share the same underlying model.
This noisy, translucent shape was the very first placement preview. Back then a placeable meant one anchor voxel and one state entity, just enough to prove a preview could become a real authoritative object in the world. Small win, but it opened the door to storage, fire, crafting stations, and eventually full voxel footprints.
This is one of the first times the rendering layers actually agreed with each other. Real streamed voxels cover the near ground, block shaped clipmap rings carry the terrain out toward four kilometres, and tree impostors bridge the gap in between. The haze is still heavy and the clouds still flat, but the horizon stopped feeling like a separate game bolted onto the front of this one.
The earliest water only had to answer two questions: where's the surface, and is the camera above it or below it? A scrolling texture and a basic underwater tint covered that much, and the hard edge you can see is everything still missing. What's running now is GPU meshed, with depth extinction, foam, waves, refraction, reflections, and underwater murk all sharing the same world fog system.
Loose stones, sticks, and mushrooms need to look accidental while still landing in exactly the same spot for every player, so their positions come from world seed, global coordinates, and salted noise, never runtime randomness. These early density passes taught me determinism is just as happy to faithfully reproduce an overcrowded forest floor as a balanced one, as the lighting bug and the overpopulated pass here both prove.
Terrain, trees, distant geometry, lighting, and fog had each existed on their own up to this point. Here they finally sat in one frame without fighting each other for attention. The seams and tuning readouts are still visible, but this was roughly where I stopped imagining what the combined systems would look like and started actually judging it.
The first slab ray march definitely produced volume, mostly straight up. Coverage was feeding way too much density vertically, so cloud banks turned into towers instead of banks. Encouraging bug at least. The marching, lighting, and noise were all clearly working, the density field just needed to learn what weather actually looks like.
Once the vertical shaping calmed down, the cloud layer started framing the landscape instead of eating it whole. The fog stack can now scatter sunlight toward the camera, and the volumetric tier reads the main light's shadows to form real light shafts. Density, scale, and cost all still need tuning, but the atmosphere had finally started reacting to light instead of just blocking it.
Because the whole game is assembled in code, most tuning belongs inside the running world, not a Unity scene. The development console exposes typed settings for atmosphere, water, foliage, character poses, world generation, and rendering paths. I can change a cloud profile, inspect the clipmap, or adjust a bow grip mid game, then save whatever worked back to the tuning data.
Dropping a Tyrannosaurus into the forest was the easy part. Giving it a believable route across terrain that players can dig apart from under it was the actual problem. Ground creatures now run a bounded surface search over live voxel columns, with step, cliff, and search budgets that keep it predictable as the landscape changes.
Dawn is a lot of quiet systems landing in the same moment at once: the fixed world clock, sun direction, sky gradient, distant terrain, tree impostors, and fog colour. No single one of them made this shot on its own, they all had to line up together. The dark foreground and the transition into distance still need work, but this is one of the first times the engine surprised me instead of just informing me.
The first campfire turned night from a lighting problem into an actual reason to stop walking. Flame and smoke come out of a custom bounded particle director rather than a Unity particle prefab, and the nearby light runs through the same custom shaders as terrain, foliage, characters, and items. Simple effect, but darkness finally had something to gather around.
A lit fire is really two systems sharing one location. The renderer handles flame, smoke, and a warm local light; separately, the authoritative simulation adds a RadiantSource that raises ambient temperature with falloff by distance. Keeping those paths apart matters: the warmth stays real even though the fire you're looking at is just client presentation.
This one's a design question more than a finished mechanic. A fire should make a camp feel safer to be at, but its flame and bloom might also make that camp visible from further away through darkness and fog than I'd like. For now the dynamic light stays deliberately local, and any future long range signalling will need to respect the difference between seeing a flame and lighting up a landscape.
These bright streaks looked like they had to be a reflection maths problem, bad wave normals, or something wrong deep in the GPU water mesh. It was none of those. One texture was just feeding extreme highlight values into an otherwise fine shader. Good reminder that the most dramatic thing on screen isn't always where the actual bug is.
Snowfall leaves an actual memory now instead of disappearing the moment the weather event ends. A presentation integrator builds up cover on upward facing, sky exposed terrain and foliage, and holds it through clear spells until the season starts turning away from winter. It's shader cover rather than real physical depth for now, but it's enough for a whole landscape to carry the history of a storm.
This first colour pass proved the seasonal routing worked, mostly by being impossible to look at. What's running now uses a palette per foliage species, keeps evergreens green, and reuses a stable hash so neighbouring deciduous trees turn at different times and different hues instead of all at once. This screenshot is the moment autumn had all the right machinery and absolutely no restraint.
Rain runs through its own dedicated GPU drop pool, but its effect on water is a lighter touch: live rain intensity adds procedural impact rings to the water's normal before lighting and reflections get evaluated. Screen space reflections then pick up nearby trees and the shoreline wherever screen depth allows it, and fall back to the sky where it doesn't.
The original placeable system stored a single anchor voxel, which was fine for a chest but made anything bigger feel hollow. Placeables can now claim a real width, height, and depth footprint, with one state entity indexing every cell they occupy. Aim at any part of this fence and the interaction, ownership, and durability all still resolve back to the same object.