The technical detail

Evolve is built on Unity 6000.4.10f1, running Entities 6.4, NetCode for Entities 1.13.2, and URP 17.4. URP handles the forward rendering foundation: the main light, cascaded shadows, camera textures, and platform integration. Everything you actually look at, terrain, water, foliage, sky, fog, rain, items, and characters, runs on custom shaders and compute written on top of that.

Terrain voxels are half a metre on each edge. A chunk column is 32 by 32 by 1024 voxels, so it covers a 16 metre footprint with 512 metres of vertical room, and meshing works in 32 cubed sections. Item models use a much finer 0.1 metre voxel scale, so a tool or a weapon can carry way more detail than the terrain grid ever could.

A world position is stored as an integer sector coordinate plus a local float offset. Horizontal sectors are 1024 metres wide at the current voxel scale. Rendering and physics stay close to a moving local origin, while simulation, persistence, and networking keep working with the real global position.

The terrain mesher sweeps all six face directions and merges compatible voxel faces into bigger quads instead of drawing every single one. The merge key factors in block material, corner ambient occlusion, and light values. There's a Burst compiled CPU version that stays the reference implementation, and the desktop client actually meshes through a two kernel compute shader for production.

The world near you streams in as full gameplay voxels you can actually dig into. Past that disc, a three ring geometry clipmap samples the same deterministic column generator without ever allocating real voxel storage. Its 8, 16, and 32 metre cells use flat tops and vertical risers to push the horizon out to roughly four kilometres.

Natural blocks sample albedo, normal, and material mask slices from shared texture arrays using world space triplanar projection, so they look right from any angle without hand painted UVs. Crafted blocks use atlas coordinates instead, since those need a deliberate face layout. Stable world coordinate hashes rotate tiles, vary colour, and add broad material variation, and none of it breaks when the origin rebases.

Gameplay state lives in unmanaged ECS components and compact blob registries rather than regular C sharp objects. Burst compiled systems and jobs process voxels, weather, vitals, flora, creatures, inventories, and projectiles in predictable groups every tick. Authoritative simulation advances at a fixed 60 Hz, while presentation work like interpolation and GPU upload just runs on the normal variable frame.

A deterministic world clock drives days, nights, and four full seasons. Weather transitions between Clear, Cloudy, Foggy, Rain, and Storm presets, and each one has separate simulation state and a separate presentation look. Rain actually changes player wetness and wind chill in the simulation, while on the client side, drivers blend fog, clouds, precipitation, surface wetness, snow cover, and autumn colour into what you see.

Blocks, items, recipes, loot, creatures, biomes, flora, trees, weather, art bindings, and tuning values are all loaded from JSON, not hardcoded anywhere. Stable string identifiers get sorted into dense runtime registries at boot. Item behaviour is built up from capability facets, like tool, food, armour, ranged, placeable, container, burner, fuel, and processor, rather than one giant item class trying to do everything.

Even single player spins up a real authoritative server world and a thin client world in the same process, talking to each other through Unity NetCode over loopback. Your input becomes movement commands, item use requests, or other discrete gameplay intents. The server validates every world mutation, then sends back entity ghosts, snapshots, and voxel deltas limited to what you're actually near.

Untouched world just regenerates from its seed every time, so there's nothing to save there. SQLite only stores what's actually changed: modified voxel cells, player state, placed entities, containers, fires, flora regrowth, scatter cooldowns, ownership, claims, tribes, and the world clock. A single background writer keeps all that database work well away from the simulation thread.

Worlds, system graphs, entity archetypes, UI, input actions, and ghost registration are all built in C sharp at runtime, not laid out in the Unity editor. Serialised assets are reserved for the handful of things Unity genuinely needs, like URP assets and shader content. An F1 development console exposes typed settings for rendering, weather, world generation, water, foliage, and character poses, so I can tune the game while it's actually running.