How to optimize an MTA:SA server: performance, tickrate and the end of lag

Connect to the server console (via local terminal or panel) and enable the internal performance monitor:

debugscript 3
showperf

The showperf command displays the average processing time per frame in milliseconds, separated by category (sync, scripts, database). Note the values on an empty server and with at least 50% of capacity occupied.

On the Linux shell, capture CPU usage per thread of the process:

top -H -p $(pgrep -f mta-server64)

The main thread (usually the first one listed with the most CPU) is where Lua scripts execute. If it’s at 95-100% and the server is multi-core, you have a single-threaded bottleneck — common in MTA, which does not parallelize Lua.

View network usage in real time:

sudo iftop -i eth0 -P -B

Note the bandwidth used per connected player. A healthy server uses 8-15 KB/s per player in normal state. Above 25 KB/s indicates a sync rate that’s too high or unnecessary broadcast in scripts.

Locate the file (usually at /home/mta/mods/deathmatch/mtaserver.conf) and open with the editor of your choice. Look for the sync sections.

Configure the intervals for a 60-100 player server aimed at fluid gameplay:

<player_sync_interval>100</player_sync_interval>
<light_sync_interval>1500</light_sync_interval>
<camera_sync_interval>500</camera_sync_interval>
<ped_sync_interval>400</ped_sync_interval>
<unoccupied_vehicle_sync_interval>1000</unoccupied_vehicle_sync_interval>
<keysync_mouse_sync_interval>100</keysync_mouse_sync_interval>
<keysync_analog_sync_interval>100</keysync_analog_sync_interval>

These values are the sweet spot for DM and roleplay. For competitive racing servers, reduce player_sync_interval to 80 and keysync_mouse_sync_interval to 80 — you gain responsiveness at the cost of ~25% more bandwidth per player.

Adjust the server FPS limit and the physics simulator resource allocation:

<fps_limit>0</fps_limit>
<server_logic_fps>100</server_logic_fps>
<bandwidth_reduction>none</bandwidth_reduction>

fps_limit=0 disables the client-side limit — this doesn’t affect the server directly but prevents players from complaining about an artificial cap. server_logic_fps=100 is the default and almost never needs changing. bandwidth_reduction set to “medium” only pays off if your total bandwidth is bursting.

Restart the server and measure again:

sudo systemctl restart mta-server

Repeat showperf and iftop after 10 minutes of operation with players. Frame times should be consistently below 12ms on the main thread.

In the server console, enable the built-in profiler for 60 seconds with the server under real load:

debugscript 3
debug-resources --top 10

The output lists the 10 resources that consume the most CPU in ms per frame. Focus on the first 3 — they generally account for 50%+ of total consumption.

Identify and eliminate setTimer with short intervals. This is the most common anti-pattern:

setTimer(function()
    for _, player in ipairs(getElementsByType("player")) do
        local money = getPlayerMoney(player)
    end
end, 50, 0)

This code runs 20 times per second iterating over all players. On a server with 80 players, that’s 1600 iterations per second just for this timer. Replace it with on-demand events:

addEventHandler("onPlayerMoneyChange", root, function()
end)

Cache results of getElementsByType and similar calls. Each call walks the server’s element tree:

local cachedPlayers = {}

addEventHandler("onPlayerJoin", root, function()
    table.insert(cachedPlayers, source)
end)

addEventHandler("onPlayerQuit", root, function()
    for i, p in ipairs(cachedPlayers) do
        if p == source then
            table.remove(cachedPlayers, i)
            break
        end
    end
end)

Iterating cachedPlayers is 10-30x faster than getElementsByType("player") in a tight loop.

On the first database load, enable WAL mode via SQL:

executeSQLQuery("PRAGMA journal_mode=WAL")
executeSQLQuery("PRAGMA synchronous=NORMAL")
executeSQLQuery("PRAGMA cache_size=-20000")

WAL allows concurrent reads with writes. synchronous=NORMAL reduces fsync without catastrophically compromising durability — accepts losing the last 1 second in case of a server crash. cache_size=-20000 allocates 20 MB of cache for SQLite.

Identify slow queries by enabling temporary logging:

local startTime = getTickCount()
local result = executeSQLQuery("SELECT * FROM accounts WHERE last_login > ?", os.time() - 86400)
local elapsed = getTickCount() - startTime
if elapsed > 50 then
    outputDebugString("Slow query: " .. elapsed .. "ms")
end

Any query above 50ms blocks the main thread and is a candidate for optimization — add indexes on search columns or pagination on large result sets.

Enable fq_codel as the qdisc on the main interface:

sudo tc qdisc replace dev eth0 root fq_codel

fq_codel eliminates bufferbloat, keeping latency consistent even with saturated bandwidth. The practical difference: players at peak hours no longer see ping go from 30ms to 200ms when total traffic grows.

Increase the kernel UDP buffers:

sudo sysctl -w net.core.rmem_max=8388608
sudo sysctl -w net.core.wmem_max=8388608
sudo sysctl -w net.core.netdev_max_backlog=5000

Persist them in /etc/sysctl.d/99-mta.conf to survive a reboot. Larger buffers absorb bursts without dropping packets, which is what causes rubberbanding when the link fills up.