Population, Spawn and AI

A bear standing on a beach looks like one thing.

To Rust, it is the meeting point of several systems.

Something decided how many bears the island should maintain. Something found a valid place to create one. Something determines whether that bear needs to be actively simulated. Other systems handle what it can perceive, how it moves, what it reacts to, what it considers important and how much server processing time all of that is allowed to consume.

Those controls are scattered across several namespaces:

bear.*
boar.*
wolf.*
crocodile.*
spawn.*
ai.*
aimanager.*
aibrainsenses.*
aithinkmanager.*

This is why separating “animal population” from “animal AI” too aggressively becomes misleading.

A living actor moves through all of them.

The current console reflects that structure particularly well. ai.* alone contains 56 current entries in our August 2026 baseline, while dormancy, sensory updates and AI processing budgets live in separate namespaces.

---

.population Means Managed Population

A ConVar such as:

bear.population

does not represent a census of every bear that happens to exist on the server.

It defines the density of the population Rust’s normal population system is responsible for maintaining.

The public administrative description used for wildlife populations is:

Population active on the server, per square km. bear.population, boar.population, wolf.population, stag.population, ridablehorse.population, panther.population and others use this wording. (Corrosion Hour)

So the basic relationship is:

map area × .population → managed population target

If:

horse.population = 1

then the population system is targeting approximately:

one managed horse per square kilometre of map.

A 6000 × 6000 m map represents:

6 × 6 = 36 km²

and a population value of 1 therefore corresponds to approximately:

36 managed animals.

The important word is:

managed.

---

Managed Population Is Not Total Population

This distinction becomes especially important once an animal can be created through another system.

Rust already allows players to hatch chickens in a Chicken Coop. Facepunch introduced the system in March 2025: a wild chicken can provide an egg, which can then be hatched and maintained by the player in a coop. (Rust)

Those player-produced chickens do not need to replace chickens in the normal managed wildlife count.

They can be tagged separately from the population maintained through .population.

So the real number of chickens present can be thought of as:

managed population

plus:

additional produced population

This is a very different concept from:

chicken.population = total number of chickens allowed on the server

The population ConVar describes what that population system is responsible for maintaining.

Other systems can add living entities on top of it.

---

The Map Is Larger Than the Island

There is another important detail in the population calculation.

The relevant area is the full map size, not merely the amount of usable terrestrial island inside it.

That difference becomes very obvious on custom maps.

Imagine a:

6000 × 6000

map containing only a small island of roughly:

1 km²

The map still represents:

36 km²

for the population calculation.

With:

.population = 1

the system can therefore be maintaining roughly 36 entities even though those entities may have only a fraction of that area available as valid terrestrial spawn space.

The useful model becomes:

full map area × .population
→ managed population target
→ valid spawn locations

The first calculation asks:

How many?

The later rules have to solve:

Where can they actually go?

---

Small Maps Make the Mathematics Visible

A 2500 procedural map is particularly useful for seeing this effect.

The world may be 2500 meters wide, but the island cannot simply consume the entire square.

Rust still needs offshore space around it for the surrounding ocean and offshore content such as the Oil Rigs.

That margin remains substantial on a small map.

On a large map, a few hundred meters around the perimeter leave a huge central area.

On a 2500 map, the same basic offshore requirement consumes a much larger proportion of the available world. By the time coastline and beach transitions are included, the actual island can be dramatically smaller than the nominal map dimensions.

The population system is still working from the full map size.

The result is easy to recognize when normal animal population values are left untouched:

animals everywhere.

Beaches and other valid areas can become crowded with wildlife because a population calculated against the entire map has to be fitted into a relatively small amount of usable land.

At sufficiently high local density, animals encounter one another constantly and the shoreline can quickly become chaotic.

That behaviour is useful evidence of a distinction that is otherwise easy to miss:

population density on the map

is not necessarily:

population density on the available island.

---

Population Is Also a Map-Design Tool

The same mechanism can be used deliberately rather than accidentally.

Consider a hunting-oriented Barren map configured with:

deer.population = 10

The intention is not merely:

Put a few more deer around.

A high deer population can become one of the defining characteristics of the environment.

Combine that population with appropriate terrain and landscape design and the island can take on the character of a hunting territory inspired by somewhere such as Anticosti Island.

Nothing fundamental has to be changed in deer AI.

The designer is changing the weight of that species in the living world.

The result comes from combining:

map area

managed population

available spawn space

population proportions

and:

existing animal behaviour

The same Rust systems can therefore produce very different ecological identities.

---

Population Ratios Matter

.population values should not necessarily be considered one at a time.

If the relative number of predators is increased, the map contains more actors capable of entering predator-related behaviours.

If prey populations dominate instead, another balance emerges.

We do not need to explain here exactly how every species reacts to every other species.

Facepunch has spent substantial effort developing believable wildlife interactions, and those behaviours belong to the AI layers discussed later in this article.

At the population level, the important point is simpler:

Population ratios change how often existing behaviours have an opportunity to meet.

A hunting-oriented island with a very large deer population and relatively low predator pressure will behave differently from a map configured with a high proportion of wolves and bears, even before a single AI behaviour is modified.

Population configuration changes the cast.

Other controls can change what that cast does.

---

Current Wildlife Population Controls

The current source baseline includes several explicit wildlife population controls. The public administrative description identifies these as populations active per square kilometre. (Corrosion Hour)

ConVar	Default	Unit	Function
bear.population	2	managed population / km² map	Bear population
boar.population	5	managed population / km² map	Boar population
wolf.population	2	managed population / km² map	Wolf population
crocodile.population	1	managed population / km² map	Crocodile population

Other wildlife currently following the same administrative pattern include deer/stag, horses, panthers and tigers. The exact current inventory should always be checked when configuring a particular server because species and defaults can change as Rust evolves. (Corrosion Hour)

The .population pattern is also not exclusive to animals. Rust uses population concepts for other world entities, although not every .population variable necessarily uses the same per-square-kilometre interpretation. The meaning remains specific to the system using it. (Corrosion Hour)

---

Population Does Not Spawn Itself

Once Rust knows the population it wants, something still has to create and maintain those entities.

That is where:

spawn.*

becomes relevant.

The current namespace contains controls for populations, groups, individuals, density, rates and administrative spawn operations. The current project baseline deliberately treats population, spawning and later AI behaviour as separate stages.

Commands include operations such as:

spawn.fill_populations

spawn.fill_groups

spawn.fill_individuals

spawn.delete_populations

spawn.report

spawn.reset_groups

The names reveal something useful even before we know every internal detail:

Population

Group

and:

Individual

are distinct concepts to Rust’s spawning machinery.

spawn.reset_groups itself is a recent addition, explicitly added in the June 2026 released changes.

---

Maintaining the Population Is Configurable

The current spawn.* controls also include separate switches for maintaining different categories:

spawn.respawn_populations

spawn.respawn_groups

spawn.respawn_individuals

along with density, rate, player scaling and tick controls.

Conceptually, that gives us another distinction:

desired population

is not the same thing as:

how the system works toward maintaining it.

An animal can die.

The population target can remain unchanged.

The spawning machinery can later attempt to restore that missing member.

---

Spawn Is Only the Beginning

Once an animal or NPC exists, the problem changes.

Now Rust needs to manage:

• active simulation;
• perception;
• alertness;
• targeting;
• food;
• navigation;
• movement;
• interactions with other entities;
• interaction with players;
• sleep and wake behaviour;
• server-performance cost.

That is where the broader AI namespaces begin to overlap.

The current project inventory describes ai.* as covering NPC and animal perception, movement, spawning, combat behaviour and sleep/wake. aimanager.* covers scheduling, dormancy, wake distance, navigation and processing budgets, while aibrainsenses.* and aithinkmanager.* expose still more specialized layers.

So there is no clean wall where:

animal configuration ends

and:

NPC configuration begins.

Some controls are species-specific.

Others are shared infrastructure.

---

Existing Is Not the Same as Thinking

One of the clearest examples is dormancy.

ConVar	Default	Range	Function
aimanager.ai_dormant	TRUE	TRUE / FALSE	AI dormancy
aimanager.ai_to_player_distance_wakeup_range	160	Undocumented	Player-distance wake range
aimanager.ai_dormant_max_wakeup_per_tick	30	Undocumented	Maximum wakeups per tick

These controls are current and sit together under aimanager.*.

They reveal an important distinction:

entity existence ≠ active AI simulation

A distant animal can continue to exist without receiving the same level of active processing it would receive while relevant to a nearby player.

The useful sequence is:

Entity exists
→ Dormant
→ Player proximity
→ Wake
→ Active simulation

This is why a distant animal appearing motionless should not immediately be interpreted as:

The animal’s AI decided to stand still.

The server may simply not be spending full AI resources on it.

---

Waking Up Has a Budget

aimanager.ai_dormant_max_wakeup_per_tick = 30

makes the performance side particularly visible.

Player proximity can make dormant AI relevant again.

But Rust also limits how many dormant AI entities can wake in one tick.

The reason is easy to understand from a server perspective.

Imagine entering an area containing a large number of dormant entities.

Activating all of their AI workloads simultaneously could create a significant spike.

Rust therefore exposes not only:

when they become relevant

but also:

how quickly that work may be activated.

---

Thinking Has a Budget Too

The same idea appears under:

aithinkmanager.*

ConVar	Default	Range	Function
aithinkmanager.framebudgetms	2	Undocumented	General AI frame budget
aithinkmanager.animalframebudgetms	2	Undocumented	Animal AI frame budget
aithinkmanager.petframebudgetms	1	Undocumented	Pet AI frame budget

 

The useful part of those names is:

ms

milliseconds.

Rust explicitly budgets server processing time for AI thinking.

So the AI system does not have only one problem:

What should this animal do?

It also has:

How much processing time are we allowed to spend deciding?

The existence of a separate:

petframebudgetms

is particularly interesting now that Rust already has pet chickens and is expanding its livestock work further. The ConVar is present in the current released control surface.

---

HTN: Planning Has Its Own Budget

Another slightly obscure term appears under aimanager.*:

aimanager.ai_htn_animal_tick_budget

aimanager.ai_htn_player_tick_budget

aimanager.ai_htn_player_junkpile_tick_budget

All currently default to:

4

HTN

HTN commonly means Hierarchical Task Network, a planning approach in which larger objectives are broken into smaller tasks.

We do not need to assume every detail of Rust’s implementation from the acronym.

The useful point is simply that Rust exposes a separate budget associated with that AI planning workload.

Again:

AI is not one calculation.

---

Sensing and Reasoning Are Separate

Current Rust exposes:

ai.npc_sensory_system_tick_rate_multiplier = 5

and:

ai.npc_reasoning_system_tick_rate_multiplier = 1

It also has a dedicated:

aibrainsenses.*

namespace.

ConVar	Default	Function
aibrainsenses.humanknownplayerslosupdateinterval	0.2	Human known-player LOS updates
aibrainsenses.knownplayerslosupdateinterval	0.5	Known-player LOS updates
aibrainsenses.updateinterval	0.5	Sensory update interval

 

LOS

LOS means Line of Sight.

That one definition makes a name such as:

knownplayerslosupdateinterval

much easier to understand.

Rust is separating at least part of the chain into:

sense

→ update knowledge

→ reason

→ act

A player simply sees:

the NPC noticed me.

The console shows more stages underneath.

---

Perception Has More Than One Input

The broader ai.* namespace also exposes:

ai.npc_alertness_drain_rate

ai.npc_alertness_to_aim_modifier

ai.npc_alertness_zero_detection_mod

ai.npc_gun_noise_silencer_modifier

ai.sensetime

ai.watchedangle

and other targeting and aiming controls.

Those names are enough to prevent an overly simple model such as:

NPC detection range = X

Alertness can change.

Noise can be modified.

Silencers can affect the input.

Angles matter.

Different systems can update at different rates.

Perception is itself a collection of conditions.

---

Movement Is Yet Another Layer

Seeing something does not guarantee that an NPC can reach it.

Current AI management exposes:

aimanager.nav_disable

aimanager.nav_wait

aimanager.pathfindingiterationsperframe

aimanager.nav_obstacles_carve_state

while ai.* contains additional navigation controls.

This gives us another distinction:

target detected

is not:

valid path found

and neither automatically means:

movement succeeds.

The animal or NPC the player sees combines those systems into one apparently continuous behaviour.

Administratively, they remain separable.

---

Relationships Can Be Configured Too

Population numbers do not fully determine how animals and NPCs interact.

Rust also exposes relationship and behaviour gates.

One example is:

ai.npc_families_no_hurt = TRUE

Another is:

ai.npc_only_hurt_active_target_in_safezone = TRUE

Neither variable should be treated as a description of an entire AI system.

Each exposes one rule inside a larger decision process.

This is why changing population ratios and changing AI rules are fundamentally different operations.

You can create more actors.

You can also change the rules governing what those actors do when they encounter something.

Both alter the resulting island.

---

Food Is Already Part of Animal AI

One current ConVar looks almost trivial:

ai.animal_ignore_food = TRUE

It is not.

The ConVar was added years ago with TRUE as its default specifically as a server optimization. Facepunch’s commit says exactly that. (Facepunch Commits)

The important behaviour appears when it is changed to:

FALSE

Animals can then consider food as part of their behaviour instead of simply ignoring food sources.

That can produce a very practical result.

An approaching wolf presented with food in its path can become interested in the food instead of continuing directly toward the player.

So this is not merely:

Food enabled / disabled

It is a branch in animal decision-making:

food exists → animal can notice it → food can compete with another behaviour

That is precisely the kind of ConVar whose short name hides a much more useful behaviour.

---

Simple AI Switches

Some broader controls remain useful precisely because they isolate large layers:

ConVar	Default	Function
ai.npc_enable	TRUE	NPC AI
ai.move	TRUE	AI movement
ai.think	TRUE	AI thinking
ai.sleepwake	TRUE	AI sleep/wake
ai.ignoreplayers	FALSE	Ignore players
ai.animal_ignore_food	TRUE	Ignore food
ai.npc_families_no_hurt	TRUE	Same-family damage gate
ai.npcswimming	TRUE	NPC swimming
ai.npchealthmultiplier	1	NPC health multiplier

All are current in the August 2026 source baseline.

The table is deliberately short.

ai.move does not need a paragraph explaining movement.

ai.animal_ignore_food does because its practical meaning is not obvious from the name.

That is the convention established in Part 1.

---

Population and Behaviour Can Produce Similar Results

Suppose a server suddenly feels much more hostile.

There are several ways that could happen.

Increase:

wolf.population

and players simply encounter more wolves.

Leave the number of wolves unchanged but modify perception, targeting or other AI settings and the same population may become more noticeable or dangerous.

Increase predator populations without changing AI at all and existing animal-to-animal behaviours occur more often simply because there are more opportunities for encounters.

The visible result can look similar:

more danger

But the mechanism can be completely different.

This is why the useful chain is broader than:

Population → AI

It is closer to:

Managed population
→ Spawn / placement
→ Existence
→ Dormancy / activation
→ Sensing
→ Reasoning
→ Navigation
→ Interaction rules
→ Visible behaviour

Several of those stages can be configured independently.

---

The Futures of Animal AI

The current controls become even more interesting when compared with what Facepunch is developing now.

This section needs one clear distinction:

some animal systems are already released; others are currently development work.

---

Pet Chickens Are Already Here

Player-managed animals are no longer purely hypothetical.

The March 6, 2025 Crafting Update introduced the Chicken Coop and player-kept chickens.

Players can obtain eggs from wild chickens, hatch them, maintain their hunger, thirst, sunlight and “Love” needs, and receive more eggs from healthy chickens. (Rust)

This already creates an important conceptual split:

wild managed population

and:

player-maintained animals

can coexist.

That distinction is exactly why .population should be understood as a managed population target, not as an absolute species cap.

---

Livestock Is Becoming a Larger System

Facepunch’s current Livestock_animals development branch shows a much broader system under active construction.

As of August 16, 2026, the branch contains recent work on cows, calves, sheep and lambs, with a dedicated LivestockAnimal class and ongoing behavioural, animation and persistence work. (Facepunch Commits)

This is development evidence, not released-game documentation.

But it gives a remarkably clear view of where animal systems are heading.

---

Following Players

The development branch has already tested livestock following interactions.

Cows can follow a player after interaction, including running to catch up if the player gets too far away. (Facepunch Commits)

Later commits deal with conflicts between following and other behaviours — for example, grazing taking priority — and with animals forgetting the person they were following after fleeing from injury. (Facepunch Commits)

That is an important detail.

The development work is not merely adding:

follow = TRUE

Different behaviours can compete for priority.

---

Grazing

Facepunch has also added a grazing behaviour in which livestock looks for suitable environmental areas such as:

Field

Forest

and:

Forestside

then moves there and grazes for a period of time. (Facepunch Commits)

This is particularly interesting beside the older:

ai.animal_ignore_food

control.

The new system is not proof that the old ConVar directly powers livestock grazing.

But the continuity is obvious:

food and environmental selection are becoming increasingly important parts of animal behaviour.

---

Fear and Reaction

Recent development work also has livestock flee when injured and flee when loud noises such as gunshots are heard nearby. (Facepunch Commits)

This is a useful contrast with simpler ambient reactions elsewhere in Rust.

Here, Facepunch is explicitly implementing danger-response behaviour for persistent livestock rather than merely triggering a decorative effect.

Again, this is current development work and may change before release. (Facepunch Commits)

---

Aging

The livestock branch also contains aging boilerplate.

Facepunch exposed a TimeToGrow field so an animal can eventually be replaced by its next-stage prefab, alongside development tooling for aging the nearest livestock animal. (Facepunch Commits)

The branch already contains:

cow → calf

and:

sheep → lamb

development work. (Facepunch Commits)

An animal is therefore becoming something that can possess a lifecycle rather than merely:

spawn → live → die.

---

Breeding

Breeding is also being assembled.

A recent commit describes animal breeding boilerplate, currently triggered through console commands while the system is being developed. (Facepunch Commits)

This brings us straight back to .population.

Once animals reproduce through a livestock system, the actual population visible on a server can increasingly contain entities whose origin is not the normal world-population manager.

The distinction becomes:

wild managed population

plus:

player-produced livestock population

rather than one universal species count.

---

Persistence

Perhaps the most significant change is that livestock is being designed to survive saves.

One development commit explicitly notes that livestock is now saved, unlike other AI, while acknowledging that this has historically been difficult. (Facepunch Commits)

That changes the nature of an animal.

A disposable world NPC can be regenerated.

A cow that a player has raised, named and maintained has to retain identity.

The same branch already includes serialized animal names and an ai.renamelivestock development ConVar. (Facepunch Commits)

The system is therefore moving toward animals that can have:

identity

state

age

behaviour

ownership-like relationships

and:

persistence

That is a much larger problem than adding another animal model.

---

Sleep

The most recent commits also include livestock sleeping behaviour and sleep-state fixes. (Facepunch Commits)

This is another example of why the existing console architecture matters.

Rust already distinguishes AI thinking, dormancy, pet frame budgets and sleep/wake behaviour.

The livestock system is adding another kind of living actor that must fit into that wider scheduling architecture.

---

Old Controls, New Uses

This is what makes:

ai.animal_ignore_food

so interesting.

It was not added in 2026 for cows and sheep.

Facepunch added it years earlier as an optimization, with food ignored by default. (Facepunch Commits)

But today the game is moving toward animals that:

• follow players;
• graze;
• react to danger;
• grow;
• reproduce;
• sleep;
• persist;
• carry names.

(Facepunch Commits)

An old, nearly invisible food-response branch suddenly fits into a much larger picture.

The new livestock work does not prove that every old AI control is being reused directly.

It shows something more interesting:

Rust has accumulated pieces of animal behaviour for years, and those pieces are increasingly becoming part of a coherent living-animal system.

---

One Animal, Many Systems

Return to the bear on the beach.

Its presence may involve:

bear.population

and:

spawn.*

Its active simulation may involve:

aimanager.ai_dormant

and:

aimanager.ai_to_player_distance_wakeup_range

Its thinking competes inside:

aithinkmanager.animalframebudgetms

Its senses and behaviour may cross:

ai.*

and:

aibrainsenses.*

Its ability to reach something involves navigation and pathfinding.

Its relationships with players or other NPCs can pass through additional behaviour gates.

The player sees:

a bear.

The server sees a managed population member, a spawned entity, a scheduled AI workload, a sensory problem, a reasoning problem, a navigation problem and a collection of interaction rules.

And increasingly, Rust is adding another possibility:

an animal that belongs to someone, has a history, and is expected to still be there tomorrow.

That is why this is no longer merely animal AI.

It is the machinery of a living island.