← Back to Blog
Game - 2026 - In development

Animal Life: Survival - NOYO Productions

📅 November 22, 2026 ⏱️ 8 min read
Animal Life: Survival is a multiplayer animal survival game from NOYO Productions, built in Unreal Engine 5.9. You are the animal: an impala, a lion, a jaguar, an elephant or a crocodile in a living wilderness. It is still in development and not released. What follows is the part I find most interesting to build: making animals move, hunt and flee in a way that feels like animals, and the engineering problems that came with it.

What I Wanted To Make

Most survival games treat animals as scenery with hit points. I wanted the opposite: the animal as the playable character, with weight, a stride that matches its body, and a world that reacts to it. Real animals are the reference, other games second. The rule I set for myself is that movement is judged by recorded motion and by how it feels to control, and numeric checks are only a diagnostic. If a graph says it is fine and it looks wrong, it is wrong.

The game is sized for a dedicated server with many players and around two thousand animals, and performance is treated as part of every change, because the target is modest hardware first and consoles later.

Where It Comes From

This is not my first animal game. NOYO Productions already makes Roblox games in the same family, among them Savannah Life, released on Roblox in June 2024 and played well over a hundred million times according to the public trackers (those totals are third-party estimates, not figures I publish). Animal Life: Survival is the next step: the same idea of being a wild animal, rebuilt as a PC game in Unreal Engine 5.9, where I can go much further on how animals move, look and behave.

Years of running a Roblox game taught me things a design document never does: what players do in the first minute, which tools a live game needs, and how much a camera or a prompt matters. Some of that came across, and some I deliberately left behind.

What carried over from the Roblox games:

  • Behaviour, not art. The input prompts that follow the device, and the way a prompt re-renders when a key is rebound, are patterns from the Roblox games. Their orange cartoon art direction is not carried over.
  • The camera. When the ground or a rock sits between the animal and the lens, the camera now pulls in along the view, the way Roblox does. My first camera orbited the animal on a level arm and pumped 16 times in 16 seconds on a hill route, with jolts up to 28 cm. The pull-in version moves about 1.8 cm RMS on the same route.
  • Live-game tooling. The analytics (funnels, segments, heatmaps) are modelled on Roblox's creator analytics, and the admin console was audited against the command setup of the Roblox games.
  • A test shortcut. One key knocks your own animal into a ragdoll and gets it back up, as in the Roblox games. It is only for test sessions.
  • One animation. The impala's swim clip started as a Roblox rig clip and was retargeted onto the new skeleton.

What I changed on purpose:

  • Realism over cartoon. Real animals are the reference for movement, not another game.
  • The first design was a purely player-driven world. My early design document had no AI animals at all: every predator and prey was a real player. The current game also has AI wildlife (herds that flee, prides that hunt), sized for around two thousand animals on a server, because an empty savanna is a poor first hour.
  • My own leg solver. The design document planned to use an off-the-shelf IK plug-in. It could not cope with every skeleton, so I wrote one that learns each animal's joints.

I also studied games I admire: The Isle and WolfQuest are references in my research notes, and a few ideas trace back to them, such as reactive music, a set of animal calls and weak prey early in a hunt. Studying them was a way to decide what to do differently, not what to copy.

The Tooling Around The Game

  • A bridge for AI coding agents. The game can host a small local server so an agent can launch it, look at it, measure it and run checks on the running game. It follows the same pattern as the official Roblox Studio and Unity relays.
  • Performance baselines. A fixed route and a regression gate judge every change in numbers first, and a profiling tool switches each subsystem off inside one live run to show what it costs.
  • A species check pack that tests every animal's feet, turns and slopes automatically, which is how the leg problems below were found.
  • An AWS backend for accounts and telemetry, with a staff admin panel.

Making Four-Legged Movement Work

  • Our own leg solver. Instead of relying on a generic IK plug-in, each animal's solver learns its joint limits from that species' own animation clips, bends the flexing joints together about learned hinge axes and uses a three-ray ground check with a spring-smoothed target. Dedicated servers still use the plug-in, since they do not draw feet.
  • Foot lock and leg warp. In a turn, each foot's stride is rotated about its hip and stretched to its own speed, so planted feet stay planted instead of skating. It is on for some species and off for others, tuned per animal.
  • Stride follows the animal's size. Cadence and stride come from a published stride-and-hip-height relationship, so a large animal takes slower, longer steps than a small one rather than the same animation at a different speed.
  • Gait phase sync. When one gait crossfades into another, the new clip starts at the old clip's phase. Without it, the crossfade averages legs that are in opposite phases and the animal looks like it is wading.
  • Turning like a body, not a tank. Velocity follows the body, so a trot or faster carves an arc no tighter than the species' minimum turn radius. At a walk or slower the body pivots on its feet at a rate that scales with mass.
  • Tails, trunks and ears. A dedicated appendage solver steps at a fixed 1/120 s with its own collision against the animal's body, and drops to cheaper levels with distance.

A World That Reacts

  • Scent. Wind wanders and follows the weather. Smells are drawn as plumes, perceived in puffs, and give a bearing rather than a position. Trails decay and water suppresses them, so predators track and prey get warned.
  • Wildlife behaviour. One brain per group updates on a round-robin, with per-animal fear and boldness, flank hunting and pathfinding over a cached terrain-cost grid.
  • Carcasses. Death is a ragdoll, simulated on every machine from a single server event. Bodies float, drift in rivers, roll down slopes and can be carried or dragged into a tree. Limbs can be torn away.
  • Swimming. The animal's float line comes from its own skeleton, and swimming begins where the water depth reaches its back.
  • The map. A procedural pipeline builds masks, scatters foliage per World Partition cell, flattens the ground where needed and tags spawn points as open or cover.

Problems That Took Real Debugging

  • A skeleton built facing the wrong way. One animal's skeleton had its feet rolled about 90 degrees from what IK expects. More than fifteen configurations of the off-the-shelf solver and a Control Rig all failed on it. The lasting answer was the own solver that learns hinge axes from the clips rather than assuming what the bones mean.
  • Remote animals' legs slid. The engine's update-rate optimisation skipped animation frames for other players' animals, so locked feet drifted. Animals within 25 m are now evaluated every frame, and the planted-foot drift dropped from roughly 50 cm/s to about 8 cm/s at the 90th percentile.
  • Folded legs on ramps. Simulated proxies never refresh their floor, so a remote animal on a slope drew with its legs folded. The fix re-runs the floor query from the replicated capsule.
  • Physics ran in slow motion below 30 fps. The engine caps a physics step at 1/30 s. The game now substeps at 1/60 s, up to 8 steps a frame, so the world runs in real time at any frame rate.
  • A knockdown deadlock. The physical-animation component ticked in parallel with mesh evaluation and blocked the game thread. A gate now ticks it after the mesh.
  • A crocodile tail that flipped 140 cm in one frame. It came from an arbitrary push-out direction at rest, convex hulls on rocks and a stack of feedback passes. Rewriting it as a fixed-step solver removed the flip.

Keeping It Fast

A server pose level of detail saved about 2.8 ms of frame time in a test with six players among sixty impala (23.5 ms down to 20.7 ms). A movement query cache made movement ticks around 22% cheaper. Wildlife has cost tiers: full simulation near a player, a cheaper middle band, and a kinematic far mode beyond about 120 m, which cut far-actor server cost from 0.85 ms to a few microseconds. With a procedural foliage scatter, switching all foliage on versus off costs only 0.1 to 0.7 ms of GPU.

What Is Done And What Is Not

Working in the current build:

  • Five playable species, turning and gait systems, the appendage solver, ragdolls and carcass handling, scent, group wildlife behaviour and the map pipeline.

Still open:

  • The movement rework is not finished: slide and turn checks still fail on several species, and the elephant's tail in turns is not right yet.
  • Hurt reactions and call animations still need clips, and all the call sounds are synthesised placeholders.
  • I have not yet measured a dedicated server under the full target of 200 players.

Planned, not built:

  • A motion-matching database for animation transitions, and tooling to measure how realistic the movement is. There is no licensable quadruped motion capture, so animation data comes from offline baking.

Want to talk about animal-driven gameplay, Unreal Engine multiplayer or procedural animation? Use the quote request form on the home page, or ask the assistant there.