Performance on busy servers: what your mod costs, and how to keep it cheap
13 min readASA DevKit as of November 2026 (UE 5.8.1)
Your mod runs fine in PIE. It's the only mod there, with one player and a handful of creatures. On a real server it runs next to forty other mods, with seventy players and twenty thousand creatures. Code that costs nothing in PIE can cost the whole server there.
Modders rarely talk about this, and server owners notice it before anyone else does. This page shows where the cost in an ARK mod comes from, the habits that keep it low, and how to measure what you have.
- You'll learn: which Blueprint habits cost the most on a server, the patterns that replace them, and how to check your mod's network traffic
- Time: 20 minutes to read; an evening to go through an existing mod
- Level: intermediate to veteran; you've shipped a mod that runs logic on a server
- You'll need: your mod, and ideally a local dedicated server to test on
Where the cost comes from
A server spends its time on two things: running code every frame, and sending changes to players. Your mod adds to both.
Anything that runs per creature adds up. One timer is cheap, but one on each of 20,000 creatures isn't. Most expensive mods aren't doing anything heavy. They do something light, on every creature, every player or every structure.
Finding actors by class, by tag or by distance has a cost that grows with what it finds.
Every replicated change goes to every player who can see it. Some kinds of sends also slow down what else that player receives.
When I counted what 23 published server mods do, three things showed up everywhere:
- Get All Actors Of Class, at 121 places;
- Get Actor Of Class, at 47;
- Delay, at 196 places in 22 of the 23 mods.
None of these is wrong by itself. They're where the cost hides.
Run less code
Tick less, or not at all
Tick runs every frame, on every actor that has it on. Anything you put there runs many times a second, per actor.
- Turn off what you don't use. Modders point out that an actor with Tick enabled costs something even with an empty Tick event. If a Blueprint doesn't use Tick, untick Start with Tick Enabled.
- Use a slower tick. Buffs have Buff Tick Server and Buff Tick Client, which run on an interval you set
with min and max times. They only run when Use Buff Tick Server or Use Buff Tick Client is on. If you
don't override them, turn those off. ARK actors also have throttled ticks:
ThrottledTickandPerformanceThrottledTick, with checkboxes like Wants Performance Throttled Tick on structures. Vanilla uses them dozens of times. - Components tick too, separately from their actor. Untick Start with Tick Enabled on components that don't
need it, or give the actor or component a Tick Interval (seconds between ticks). In Unreal the
dumpticksconsole command lists everything ticking; I haven't checked it in the kit's PIE. - A Timeline costs like Tick while it plays. It updates every frame, so use it only for smooth per-frame blends. Timers, delays and the other nodes that remember has the timer traps.
- Use a timer when you need "every few seconds". A looping timer every 5 seconds runs a tiny fraction as often as Tick. A timer by function name only fires for functions with no inputs, so call a wrapper with no inputs.
Creatures already slow their own tick when they're idle. Modders who printed from a Rex's tick saw it tick constantly in a fight and only every few seconds standing still. Don't fight that by adding your own fast tick.
Count the nodes, not the work
Blueprint pays a fixed cost for every node it runs, whatever the node does. A line trace costs about the same Blueprint overhead as a Print String; the trace itself is fast native code. So long chains of small nodes inside a loop are where Blueprint time goes. Use one node that does the job over five that build it.
Pure nodes (the ones without white execution pins) add a trap: they run again for every pin that reads them. A Select node evaluates every input, not just the one it picks. A pure function wired to five pins runs five times. Store the result in a local variable, or use a Branch. Lessons §2 has the same trap in For Each loops.
Let the material do the moving
A fade, a pulse or a spinning prop doesn't need Tick or a Timeline. Pass the start time to a material parameter once, and let the material blend on the GPU. RotateAboutWorldAxis or SimpleGrassWind in World Position Offset spins or sways a mesh with no code running. World Position Offset only moves the picture, not the collision, so keep it for decoration.
It isn't free on the GPU, though. World Position Offset (and Pixel Depth Offset) makes a Nanite mesh more expensive to draw, and most vanilla structure meshes are Nanite. The viewport's Nanite Visualization → Evaluate WPO view shows which meshes pay. Keep it on small decorative meshes, and don't add it to a parent many meshes share. It also doesn't move the mesh's bounds: a mesh pushed far from its spot vanishes when its original spot leaves the screen.
Reuse instead of creating
Creating and destroying objects feeds garbage collection, which pauses the game to clean up. In Epic's 5.8 profiling talk, one game threw away 40,000 objects a minute and paid 2 ms a frame for it. Keep and reuse widgets, effects and helper objects you need again, and create them when they're first needed, not all up front.
One manager, not one timer per thing
The biggest win in most mods: don't give every creature, player or structure its own timer. Keep one actor (your singleton) with a list of the things it cares about, and one slow timer that works through the list.
- Keep the list up to date from events:
OnShooterCharacterSpawnedandOnShooterCharacterDiedfor players, your own place and destroy events for structures. Then you never have to search for them. - Default buffs on every creature are expensive. A buff is a full actor with its own network channel.
Additional Default Buffs on
PrimalDinoCharactermeans a buff actor per creature, wild ones included. If your buff only matters for some creatures, check in the buff's setup and remove it straight away from the rest.
Don't search the world on a loop
Get All Actors Of Class has a worse reputation than it deserves. Finding the actors is rarely the slow part: an Epic engineer explained in early 2025 that it looks them up by class, not by searching the whole map. If you only read the result's length, it costs next to nothing. The reputation comes from older advice, including Epic's own talks, which call it expensive and have actors register with a manager instead. Both sides agree on the manager pattern.
The cost is what mods do with the result. Loop over every creature, cast each one and run logic on it, every few seconds, from a buff that every player has, and that's thousands of actors' worth of work, many times a second.
- Cache what doesn't change. Cast to the game mode once and keep it. Find your singleton once and keep it. Never call Get Actor Of Class inside a buff that exists per player or per creature.
- Search by area when you mean an area.
ServerOctreeOverlapActorsandServerOctreeOverlapActorsClassfind actors within a radius, and vanilla uses them. Cap how many results you handle. - Use the lists the game already keeps.
GetCustomActorListwith a tag, andGetSpecialActorList, return lists the game maintains. Wildcard's own game mode uses both.
Spread big jobs over time
Some jobs have to touch everything: a wipe, an audit, a cleanup. Do it in batches, a fixed number per timer step:
Start the job:
if a job is already running: stop here
mark the job as running
Pending = Get All Actors Of Class (once, for the whole job)
Index = 0
start a looping timer: Step
Step:
handle Pending[Index] up to Pending[Index + BatchSize - 1], skipping any that are no longer valid
Index = Index + BatchSize
if Index has reached the end: stop the timer, mark the job as done, report once
Put the batch size and the interval in your ini settings, so a server owner can slow it down.
Three guards every long job needs:
- A running flag. A second admin command mustn't reset the first job halfway through.
- A ceiling on every While loop. A loop over bad data runs forever and freezes the server.
- A quiet period for bursts. Creatures spawn in bursts, and
OnPreSpawnedDinofires once for each. Collect them, and handle the batch once after a short pause. A Retriggerable Delay of about 0.2 seconds works.
Send less over the network
Most of a server's network load is the game's own: creature and player movement, structures streaming in when a player arrives, combat effects and inventory transfers. Your mod adds to it, and a few habits make it much worse.
Replicate state, don't stream it
- Use a replicated variable with RepNotify for anything that lasts. A zone's size, a match's state, a train's speed. Every player gets it when the actor reaches them, including players who arrive later.
- Never send lasting state by multicast. A multicast only reaches players who can see the actor at that moment. Anyone who arrives later never gets it.
- Never multicast from Tick, a timeline or a loop. Send the start and end state and the start time once, and let each client play it out locally.
- Send per-player data only to that player. Use the owner-only condition, or
MulticastPropertyToPlayer. - Never broadcast other players' positions to everyone. Filter on the server.
ARK sends most of its own state once, when an actor reaches a player, and pushes later changes by name. If your actor goes dormant, see the push idiom.
Reliable calls on the player slow their base loading
This one is ARK-specific, and it's easy to miss.
ARK limits how many structures it sends each player per second, to about 800. While any ordinary reliable call to that player's controller or character is in flight, it cuts that number, by default down to zero. Only a few game calls (item and tracking updates) are exempt, and a Blueprint call can't be.
So a stream of reliable Run on Owning Client events through the player controller stalls that player's structures. Big bases load in slowly, or not at all, until the stream stops. It hurts most right after login and respawn, which is exactly when mods like to send their setup.
- Make calls that repeat (UI refreshes, progress, counters) unreliable.
- In any Unreal game, a reliable call every frame can also fill the queue of unacknowledged reliable calls (256), and the client is disconnected with a reliable buffer overflow.
- Keep reliable calls for rare events that must arrive: a purchase, an admin action, a menu result.
- Send one summary instead of one call per item.
Few always-relevant actors
Always Relevant makes an actor go to every player, whatever the distance. Every one costs a channel on every client. Use it for one or two things that really are global, like a match state actor, not for every actor your mod spawns.
Things that stop running
The opposite problem: logic that stops because the game is saving effort.
- Stasis: Creatures and structures far from every player go into stasis. They stop ticking, and their timers don't fire. A modder found in 2024 that a looping timer on a structure didn't fire on a live server until a player came near, even with stasis turned off on it. If something must run with nobody around, run it from your singleton. Modders report that a plain actor like it doesn't go into stasis the way creatures and structures do.
- Throttled creatures: Idle creatures tick slowly. Don't measure time by counting ticks: use the delta time you're given, or a clock.
Works in PIE, not on a server covers the stasis symptoms.
Measure it
You can't easily profile one mod among forty on a live server: modders who've asked found no good way. What you can do is measure your mod alone, and keep it lean by habit.
Count your per-thing costs. List every timer, tick and buff your mod creates, and multiply by how many things get one. A buff on every creature on a big map is tens of thousands of actors.
Watch the frame time. In PIE,
stat unitshows the whole frame next to the time spent on the game thread (Game), the render thread (Draw) and the GPU. Whichever sits closest to Frame is your bottleneck: Game means your Blueprints and actors, Draw or GPU means meshes, materials and lights.stat unitgraphplots it over time. PIE runs the server and your client in one process, so it's a rough check, not a server measurement. Compare a run with your mod and one without, with the same creatures around, and talk in milliseconds, not frames per second.More ways to measure
- Keep the test the same: same resolution and camera, the editor window minimized around PIE, one change at a time.
stat gameshows world tick time;stat gpusplits GPU time by pass (shadows, base pass);stat scenerenderingandstat rhicount draw calls and triangles.profilegpu(or Ctrl+Shift+Comma) opens the GPU Visualizer. Sort by duration and open the biggest bar. In Epic's demo it led straight to point lights casting shadows over a huge radius.- Find a slow graph by halving it. Disconnect half, measure, repeat. Spikes usually come from spawning many actors or starting many effects in one frame.
- Stop what changes on its own: wandering creatures, weather, drifting effects. A steady test gives a flat line
in
stat unitgraph. - Count your objects.
obj list -countsortlists loaded objects by class, most first; addclass=<Name>for one class. Run it with and without your mod on the same save. More objects means longer garbage-collection hitches.obj refs shortest name=<full path>prints what keeps one object loaded. (UE 5.8 talk; spelling as spoken, so check it in your kit.) - Sounds: Audio Insights is in the kit (sounds and effects).
- The standalone Unreal Insights app isn't in the kit's
Engine\Binaries\Win64folder, though the editor has its Insights modules. Viewing a saved trace probably needs a matching Unreal install from the Epic launcher. I haven't tried it.
Look at your network traffic. In PIE, type
netprofilein the console to start recording, and again to stop. The DevKit writes a.nproffile toProjects\ShooterGame\Saved\Profiling\. Open it with the Network Profiler that ships with the kit,Engine\Binaries\DotNET\NetworkProfiler.exe. It breaks down every property and call your actors sent.Test on a local dedicated server with many creatures. PIE hides most of this. Testing your mod shows how to set one up.
Common mistakes
The server got slower after my mod was added, but my mod "does nothing"
Look for things that happen per creature or per player: a default buff on every creature, a timer in a buff's setup, a Get Actor Of Class in a buff. Each is cheap once and expensive twenty thousand times.
Bases load in slowly for players using my mod
Your mod is probably sending reliable calls to the player controller or character in a stream, often at login. Make the repeating ones unreliable, or send one summary.
My buff has Use Buff Tick Server on but doesn't override it
Turn the flag off. With it on, the buff still calls the empty event on its schedule.
My job froze the server
A While loop without a ceiling, or a world search in one go. Batch it, and give every loop a maximum.
Late joiners don't see my effect
You sent lasting state by multicast. Move it to a replicated variable with RepNotify.
Go deeper
- Timers, delays and the other nodes that remember: what timers, Delay, Do Once and Timelines do when called again.
- Works in PIE, not on a server: who runs what, and how to send state to clients.
- How to run global logic: the manager actor this page keeps pointing to.
- Every Mod Data Asset field: Additional Default Buffs and what it creates.
- Sparse class data: why override managers must be cheap.
Sources
- General Unreal videos (not ARK-specific, not checked in the kit): Ben Cloward on a steady test (2025) and World Position Offset on Nanite (2025); WPO bounds (2021); all auto captions.
- Unreal Fest 2026 talks (UE 5.8, the kit's version; auto captions): counting objects, what keeps an object loaded and reusing objects (Profiling with Pirates, 2026-07-14).
- General Unreal videos (not ARK-specific, not checked in the kit): reading
stat unitandprofilegpu(Epic, manual, 2022); the stat pages and a consistent setup (Epic, manual, 2020); motion in the material (Epic, manual, 2019); timelines cost like tick, halving the graph (Epic, auto, 2015). - General Unreal videos (not ARK-specific, not checked in the kit): cost per node and Get All Actors and managers (Epic, manual); Select and pure nodes (auto); component ticks and
dumpticks(auto); reliable buffer overflow (Epic, manual). - The game's compiled code, read offline on the 5.8.1 DevKit: the dormant structure budget of 800 per second per
player and its cut to 0 during reliable controller and pawn calls, the exempt calls, buff tick scheduling, the
replication graph,
MulticastPropertyand the priority settings. - The DevKit's files: the throttled tick hooks and how often vanilla overrides them, the octree and actor list
functions, Wildcard's game mode, and
NetworkProfiler.exein the kit. - My count of 23 published server mods: how often they use Get All Actors Of Class, Get Actor Of Class, Delay,
MulticastPropertyandFlushNetDormancy. I don't name them. - My PIE tests: buff tick intervals, and client health updates arriving about every half second.
- Discord threads (open for server members):
- an Epic engineer's note on Get All Actors Of Class (2025-01);
- modders on performance going untested next to other mods, and idle ticks (2025-10);
- structure timers not firing on a live server until a player came near (2024-05);
- creatures slowing their tick when idle (2024-06);
- throttled tick checkboxes on structures (2024-05);
- the
netprofilecommand and the Network Profiler (2025-10); - no good way to profile one mod among many on a live server (2025-02).
Community knowledge from the ARK Modding Community Discord (discussions from May 2024 to October 2025), found with Overseer.
Where this page's information comes from
Applies to: ASA DevKit as of November 2026 (UE 5.8.1)
the game's compiled code, my count of published server mods, my PIE tests and the community Discord (see Sources)