# xHLDS settings (/docs/xhlds/settings)

The settings xHLDS adds on top of ReHLDS. They all start with `xhlds_`, so they never look like ReHLDS's own `sv_rehlds_*` settings. ReHLDS's settings work in xHLDS as they do in ReHLDS: see the [ReHLDS settings](/docs/rehlds/settings). Most servers keep the defaults.

## How to change a setting [#how-to-change-a-setting]

A setting (a "cvar") is a name and a value, for example [`xhlds_voice_rate 12000`](/docs/xhlds/settings#xhlds_voice_rate).

- **To keep it:** add the line to `server.cfg` in the game folder (`cstrike/server.cfg` for Counter-Strike 1.6). The server runs that file when it starts and at every map change.
- **To try it now:** type the line on the server console, or send it over rcon. It lasts until the server restarts or a config file sets it again.
- **To see the current value:** type just the name on the console.

New to these words? The [glossary](/docs/glossary) explains them.

## How to read an entry [#how-to-read-an-entry]

- The first line says what the setting does.
- **Default** and **Since**: the value it has if you set nothing (from the xHLDS source), and the first xHLDS release that has it.
- **Values**: what each value does.
- **When to change it**: whether you need to touch it at all.
- **Technical details**: what you see on the console and how it works with other settings, for admins who want it.

## All settings [#all-settings]

| Setting | What it does | Default |
|---|---|---|
| [`xhlds_update_schedule`](#xhlds_update_schedule) | With -pingboost 5, players get as many world updates a second as they ask for, and their updates are spread over the server's frames instead of all going out in the same frame. | `1` |
| [`xhlds_datagram_warnings`](#xhlds_datagram_warnings) | How much the console tells you about data a player did not get. | `1` |
| [`xhlds_datagram_budget`](#xhlds_datagram_budget) | Keeps the sounds, effects and HUD messages a plugin sends from crowding out the updates that show players where everyone is. | `1` |
| [`xhlds_overflow_fullupdate`](#xhlds_overflow_fullupdate) | Helps a player catch up when the world around them changes so much at once that the update no longer fits in one packet, so they don't go a moment without seeing anything move. | `1` |
| [`xhlds_voice_rate`](#xhlds_voice_rate) | The most voice data one player may send each second. | `12000` |
| [`xhlds_voice_burst`](#xhlds_voice_burst) | How much voice a player may send at once on top of xhlds_voice_rate, for example the voice their game sends in one go after a short lag spike. | `16384` |
| [`xhlds_voice_punish_after`](#xhlds_voice_punish_after) | After how many seconds of voice over the limit, without a break, a player is kicked or banned as xhlds_voice_punish says. | `0` |
| [`xhlds_voice_punish`](#xhlds_voice_punish) | What happens to a player who keeps sending voice over the limit for longer than xhlds_voice_punish_after allows. | `-1` |
| [`xhlds_maxclients_per_ip`](#xhlds_maxclients_per_ip) | The most players the server lets in at the same time from one IP address, counting players in game and players still connecting. | `0` |
| [`xhlds_api_guard`](#xhlds_api_guard) | Some plugin mistakes that would stop the server under ReHLDS are skipped instead, so the server keeps running, and each one is reported on the console with the file that made it. | `1` |
| [`xhlds_api_warnings`](#xhlds_api_warnings) | How much the console tells you about the plugin mistakes xhlds_api_guard handles. | `1` |
| [`xhlds_confilter_enable`](#xhlds_confilter_enable) | Turns the console filter on or off. | `1` |
| [`xhlds_confilter_logs`](#xhlds_confilter_logs) | Whether the console filter's rules also apply to the server's log files. | `0` |
| [`xhlds_precache_warnings`](#xhlds_precache_warnings) | How often the console warns that the server tried to play a sound that is not precached, for example one removed by an unprecacher plugin. | `1` |
| [`xhlds_stats_players`](#xhlds_stats_players) | Whether the server publishes a JSON line per player for plugins at the end of each statistics window. | `1` |
| [`xhlds_stats_net_key`](#xhlds_stats_net_key) | An optional secret that lets the per-player statistics show which players connect from the same network, across all your servers, without storing their addresses. | empty |
| [`xhlds_stats_profile`](#xhlds_stats_profile) | How much detail xhlds_stats profile gives about where the server's frame time goes, so you can tell whether lag came from the game, a plugin, the network or the machine. | `2` |
| [`xhlds_stats_window`](#xhlds_stats_window) | How many seconds of play each xhlds_stats report covers. | `60` |
| [`xhlds_crash_owner`](#xhlds_crash_owner) | The Steam accounts that may see this server's crash reports on Hostsrc's crash service. | empty |
| [`xhlds_stats_players_json`](#xhlds_stats_players_json) | An output for plugins, not a setting. | empty |
| [`xhlds_stats_profile_json`](#xhlds_stats_profile_json) | An output for plugins, not a setting. | empty |
| [`xhlds_stats_json`](#xhlds_stats_json) | An output for plugins, not a setting. | empty |

## Frame timing [#frame-timing]

### `xhlds_update_schedule` [#xhlds_update_schedule]

With `-pingboost 5`, players get as many world updates a second as they ask for, and their updates are spread over the server's frames instead of all going out in the same frame.

**Default:** `1`. **Since:** xHLDS 3.15.0-hs.9.

**Values:** `1` on. `0` the ReHLDS rule for when a player's next update is due.

**When to change it:** Leave it at `1`. Set `0` only to compare with ReHLDS. It only does anything with `-pingboost 5`; with `-pingboost 1` to `3` the server always uses the ReHLDS rule, so their timing stays as it was.

**Technical details:** A world update tells a player's game where everyone is, `cl_updaterate` times a second, limited by `sv_minupdaterate` and `sv_maxupdaterate`. With `1` each player keeps their own schedule: an update missed during a long frame (a slow plugin, a map load) is skipped, not sent twice, and the next one is back on that player's own time. A player who joins, or comes back after a map change, starts in the least busy frame. A change takes effect from every player's next update.

To check it, compare `Pkt/s` (updates a player got each second) with `UR` (the update rate they asked for, after the server's limits) in [`xhlds_stats players`](/docs/xhlds/commands#xhlds_stats): they should be close. [`xhlds_stats profile`](/docs/xhlds/commands#xhlds_stats) shows whether sending to players takes much of some frames and little of others.

## Dropped data and overflows [#dropped-data-and-overflows]

### `xhlds_datagram_warnings` [#xhlds_datagram_warnings]

How much the console tells you about data a player did not get: sounds, effects and messages that were dropped, world updates that did not fit, voice over the limit, and players who timed out.

**Default:** `1`. **Since:** xHLDS 3.15.0-hs.5.

**Values:** `0` no lines. `1` short coded lines, at most one per player every 10 seconds. `2` the same, plus a line for every dropped message with the module that sent it, and ReHLDS's own overflow lines.

**When to change it:** Leave it at `1`. Use `2` for a short time when you look for the plugin behind `XH-D01` or `XH-D02` lines; it prints a lot. Use `0` only if you don't want any of these lines.

**Technical details:** With `1` you see:

- `XH-D01`: a player missed sounds, effects or other messages because more was queued for them than one packet can carry.
- `XH-D02`: a player missed messages because they were over the player's rate (see [`xhlds_datagram_budget`](/docs/xhlds/settings#xhlds_datagram_budget)).
- `XH-T01`, `XH-T02`, `XH-T03`: a player timed out while connecting, while loading the map, or in game.
- `WARNING: msg overflowed for <player>`: a world update did not fit the player's packet, once per run of such packets, with the entities that filled it (for example `118 weaponbox, 40 env_sprite`). See [`xhlds_overflow_fullupdate`](/docs/xhlds/settings#xhlds_overflow_fullupdate).
- `Voice data dropped from "<player>"`: voice over [`xhlds_voice_rate`](/docs/xhlds/settings#xhlds_voice_rate), at most one line per player every 10 seconds.

[`xhlds_explain <code>`](/docs/xhlds/commands#xhlds_explain) prints what a code means and what to do. With `2`, each dropped message gets its own line naming the module that sent it, for example `amxmodx_mm_i386.so`: that names the module, not the AMX Mod X plugin. To find the plugin, pause suspected plugins one at a time (`amxx pause <plugin>`) and watch whether the lines stop. At `2` you also get ReHLDS's `SZ_GetSpace: overflow on <player>` lines, a line for every packet without a world update, and a `Voice packet dropped` line for every dropped voice packet instead of the summary.

Bots are never reported. A player who has stopped answering gets no `XH-D` lines; if they don't answer again, an `XH-T` line says so.

### `xhlds_datagram_budget` [#xhlds_datagram_budget]

Keeps the sounds, effects and HUD messages a plugin sends from crowding out the updates that show players where everyone is.

**Default:** `1`. **Since:** xHLDS 3.15.0-hs.5.

**Values:** `1` when a plugin sends a player more than their `rate` can carry, the extra messages are dropped and the player keeps getting world updates. `0` as in ReHLDS: the messages go out, and the player gets fewer world updates.

**When to change it:** Leave it at `1`. Set `0` only to compare with ReHLDS.

**Technical details:** Normal play is not affected. When messages are dropped this way, the console reports it as `XH-D02` (with [`xhlds_datagram_warnings`](/docs/xhlds/settings#xhlds_datagram_warnings) at `1` or `2`), and [`xhlds_stats players`](/docs/xhlds/commands#xhlds_stats) shows the dropped data per player.

Plugins that send a message every server frame send more at a higher frame rate, for example with a higher `sys_ticrate` or `-pingboost 5`, so this is where it matters most.

**Note:** The players' rate limits themselves come from `sv_minrate` and `sv_maxrate`.

### `xhlds_overflow_fullupdate` [#xhlds_overflow_fullupdate]

Helps a player catch up when the world around them changes so much at once that the update no longer fits in one packet, so they don't go a moment without seeing anything move.

**Default:** `1`. **Since:** xHLDS 3.15.0-hs.5.

**Values:** `1` after an update that did not fit, the player gets full updates until one arrives. `0` as in ReHLDS.

**When to change it:** Leave it at `1`. Set `0` only to compare with ReHLDS.

**Technical details:** This happens when a player suddenly sees many new entities: a spectator looking over the map, a pile of dropped weapons, or many sprites from a plugin. Under ReHLDS the player can go without world updates for a short while until their game gives up and asks for a full one. With `1` the server sends a full update straight away, which usually fits.

Each such run is reported once as `WARNING: msg overflowed for <player>` (with [`xhlds_datagram_warnings`](/docs/xhlds/settings#xhlds_datagram_warnings) at `1` or `2`), with the entity classes that filled the update. Many of these lines on one map point at the map or a plugin creating too many entities.

## Voice [#voice]

### `xhlds_voice_rate` [#xhlds_voice_rate]

The most voice data one player may send each second. Voice above it is dropped before other players and voice plugins get it, so one player flooding voice can't lag everyone who hears them.

**Default:** `12000`. **Since:** xHLDS 3.15.0-hs.6.

**Values:** Bytes a second. `0` no limit, as in ReHLDS.

**When to change it:** Leave it as it is. If players who are only talking show up in `Voice data dropped from "<player>"` lines, raise it or set `0`.

**Technical details:** Each drop is reported on the console as `Voice data dropped from "<player>"`, at most one line per player every 10 seconds, with how much was dropped (see [`xhlds_datagram_warnings`](/docs/xhlds/settings#xhlds_datagram_warnings)). The voice is dropped before voice plugins such as Revoice or VoiceTranscoder see it, so servers running them are covered too.

The default is set from published voice codec figures, not measured on real players. The limit does not apply with `sv_voiceenable 0`, to bots, or to a listen server's own player.

**Note:** Related: [`xhlds_voice_burst`](/docs/xhlds/settings#xhlds_voice_burst), [`xhlds_voice_punish_after`](/docs/xhlds/settings#xhlds_voice_punish_after), [`xhlds_voice_punish`](/docs/xhlds/settings#xhlds_voice_punish).

### `xhlds_voice_burst` [#xhlds_voice_burst]

How much voice a player may send at once on top of [`xhlds_voice_rate`](/docs/xhlds/settings#xhlds_voice_rate), for example the voice their game sends in one go after a short lag spike.

**Default:** `16384`. **Since:** xHLDS 3.15.0-hs.6.

**Values:** Bytes. One voice packet of the largest size always gets through, whatever you set.

**When to change it:** Leave it as it is unless players who are only talking show up in `Voice data dropped from "<player>"` lines right after a lag spike; then raise it.

**Technical details:** Voice over [`xhlds_voice_rate`](/docs/xhlds/settings#xhlds_voice_rate) plus this allowance is dropped and reported like any other voice over the limit. [`xhlds_voice_rate 0`](/docs/xhlds/settings#xhlds_voice_rate) turns the limit off, and this setting with it.

### `xhlds_voice_punish_after` [#xhlds_voice_punish_after]

After how many seconds of voice over the limit, without a break, a player is kicked or banned as [`xhlds_voice_punish`](/docs/xhlds/settings#xhlds_voice_punish) says.

**Default:** `0`. **Since:** xHLDS 3.15.0-hs.6.

**Values:** Seconds. `0` never: voice over the limit is only dropped and reported.

**When to change it:** Leave it at `0` if dropping the extra voice is enough. Set a few seconds if voice floods bother your players and you want the flooder removed.

**Technical details:** Players who are only talking stay under [`xhlds_voice_rate`](/docs/xhlds/settings#xhlds_voice_rate), so they are not affected. Check the `Voice data dropped from "<player>"` lines first: if normal players show up there, raise [`xhlds_voice_rate`](/docs/xhlds/settings#xhlds_voice_rate) before you turn punishments on.

### `xhlds_voice_punish` [#xhlds_voice_punish]

What happens to a player who keeps sending voice over the limit for longer than [`xhlds_voice_punish_after`](/docs/xhlds/settings#xhlds_voice_punish_after) allows.

**Default:** `-1`. **Since:** xHLDS 3.15.0-hs.6.

**Values:** `-1` kicks the player ("Kicked for voice flooding"). `0` bans their address for good. A number: bans their address for that many minutes, as `addip` does.

**When to change it:** Only matters when [`xhlds_voice_punish_after`](/docs/xhlds/settings#xhlds_voice_punish_after) is above `0`. A kick is enough for most servers; use a ban if the same address keeps coming back to flood.

**Technical details:** The values work like ReHLDS's punish settings, such as [`sv_rehlds_movecmdrate_avg_punish`](/docs/rehlds/settings#sv_rehlds_movecmdrate_avg_punish). The console gets a line with the player's name and address, for example `"<player>" (<address>) kicked for voice flooding`. A banned player sees "Banned for voice flooding".

## Players per address [#players-per-address]

### `xhlds_maxclients_per_ip` [#xhlds_maxclients_per_ip]

The most players the server lets in at the same time from one IP address, counting players in game and players still connecting.

**Default:** `0`. **Since:** xHLDS 3.15.0-hs.6.

**Values:** `0` no such limit, as in ReHLDS. A number: a new player from an address that already has that many players on the server is refused.

**When to change it:** Leave it at `0` when players reach your server through an anti-DDoS proxy, a partner's relay, Docker's userland proxy or a boost service: the server then sees only a few addresses, and any limit caps the whole server. Otherwise, if one address fills your server with players or fake players, set a number above the most real players you expect from one address. Internet cafés, schools, families and mobile carriers put several real players behind one address.

**Technical details:** A refused player sees "Too many players from your IP address", and the server log gets a `Too many clients from <ip:port>` line.

Never counted: bots, HLTV proxies (`sv_proxies` limits those), a player reconnecting into their own slot, everyone while `sv_lan` is `1`, and players from private addresses (127.x, 10.x, 172.16.x to 172.31.x, 192.168.x), which can only come from the server's own network.

**Note:** ReHLDS's [`sv_rehlds_maxclients_from_single_ip`](/docs/rehlds/settings#sv_rehlds_maxclients_from_single_ip) keeps working as in ReHLDS. It only counts players who are still connecting, so it does not stop one address from filling the server one player at a time. The two settings work side by side.

## Plugin mistakes [#plugin-mistakes]

### `xhlds_api_guard` [#xhlds_api_guard]

Some plugin mistakes that would stop the server under ReHLDS are skipped instead, so the server keeps running, and each one is reported on the console with the file that made it.

**Default:** `1`. **Since:** xHLDS 3.15.0-hs.6.

**Values:** `1` the server skips the one bad call where that is safe and keeps running. `0` the server stops, as in ReHLDS.

**When to change it:** Leave it at `1`. Set `0` only to see the original behaviour while you debug a plugin.

**Technical details:** These are calls a plugin or the game makes to the engine in a way the engine refuses, for example a message an AMX Mod X plugin started and never finished because of a runtime error, a message sent to something that is not a player, a precache after the map has loaded, or a model set on an entity that was never precached. Under ReHLDS such a call ends in `FATAL ERROR` or `Host_Error`, a restart and a map reload. With `1`, the server undoes that one call and carries on.

A missing file or a bad name precached by the game itself (for example `cs.so`) still stops the server with either value: that usually means broken map or game files, which should not be hidden.

Either way, every such call is printed on the console (see [`xhlds_api_warnings`](/docs/xhlds/settings#xhlds_api_warnings)) and counted (see [`xhlds_api_incidents`](/docs/xhlds/commands#xhlds_api_incidents)). The mistake is still in the plugin: use the reports to find and fix it. You can change the value while the server runs.

### `xhlds_api_warnings` [#xhlds_api_warnings]

How much the console tells you about the plugin mistakes [`xhlds_api_guard`](/docs/xhlds/settings#xhlds_api_guard) handles.

**Default:** `1`. **Since:** xHLDS 3.15.0-hs.6.

**Values:** `0` no lines. `1` the first case from each module on each map at once, then at most one summary line per case every 10 seconds, saying how many more there were and from which modules. `2` a line for every call.

**When to change it:** Leave it at `1`. Use `2` for a short time when you are tracking down one plugin; `0` only if you already know the cause and the lines are in the way.

**Technical details:** Each line looks like `API misuse: <case>: <what was called>; called from <module>+0x<offset>; <what the server did>`. The module is the file that made the call, for example `amxmodx_mm_i386.so` for AMX Mod X's own functions or `fakemeta_amxx_i386.so` for `engfunc`. It names the module, not the AMX Mod X plugin: look in the AMX Mod X error log at the same moment to find the plugin. "the game library, through Metamod" means the game made the call through Metamod.

A call that stops the server is always printed, whatever the value, just before the `FATAL ERROR` line, so the last thing on the console says what happened.

## Console [#console]

### `xhlds_confilter_enable` [#xhlds_confilter_enable]

Turns the console filter on or off. The filter hides console lines you never want to see, using rules you write in `xhlds_confilter.txt`.

**Default:** `1`. **Since:** xHLDS 3.15.0-hs.6.

**Values:** `1` lines that match a rule are hidden. `0` every line is printed, rules or not.

**When to change it:** Leave it at `1`. Without a rules file the filter does nothing, so `1` changes nothing on a server that has none. Set `0` for a moment when you want to see everything, for example while you look into a problem.

**Technical details:** [`xhlds_confilter enable`](/docs/xhlds/commands#xhlds_confilter) and [`xhlds_confilter disable`](/docs/xhlds/commands#xhlds_confilter) set this value too. Lines that report a fatal error, and the filter's own `xhlds_confilter:` lines, are always printed, even when a rule matches them. The rules file, its format and what the filter covers are explained under the [`xhlds_confilter`](/docs/xhlds/commands#xhlds_confilter) command.

### `xhlds_confilter_logs` [#xhlds_confilter_logs]

Whether the console filter's rules also apply to the server's log files.

**Default:** `0`. **Since:** xHLDS 3.15.0-hs.6.

**Values:** `0` the log files get every line, as before. `1` the rules also hide lines from the log files (`logs/*.log`) and from `logaddress` listeners.

**When to change it:** Leave it at `0` if stats tools, ban systems or panels read your logs, so they keep seeing everything. Set `1` only if the lines you hide are noise in the logs too.

**Technical details:** With `0`, a line hidden on the console is still in the log files. Crash reports always keep every console line, hidden or not, with either value, so a crash report still shows what led up to it.

### `xhlds_precache_warnings` [#xhlds_precache_warnings]

How often the console warns that the server tried to play a sound that is not precached, for example one removed by an unprecacher plugin.

**Default:** `1`. **Since:** xHLDS 3.15.0-hs.5.

**Values:** `0` never. `1` once per sound per map, with the sound's name. `2` every time, as in ReHLDS.

**When to change it:** Leave it at `1`. Use `2` if you want to see how often a missing sound is played; `0` if you removed sounds on purpose and don't want the lines.

**Technical details:** The sound is not played with any value; this only changes how often you are told. With `1`, after many different missing sounds on one map, one more line says the rest of that map is not reported.

## Statistics [#statistics]

### `xhlds_stats_players` [#xhlds_stats_players]

Whether the server publishes a JSON line per player for plugins at the end of each statistics window.

**Default:** `1`. **Since:** xHLDS 3.15.0-hs.6.

**Values:** `1` at the end of each [`xhlds_stats`](/docs/xhlds/commands#xhlds_stats) window, [`xhlds_stats_players_json`](/docs/xhlds/settings#xhlds_stats_players_json) is set once for each player of the window. `0` it is not set.

**When to change it:** Set `0` if no plugin reads [`xhlds_stats_players_json`](/docs/xhlds/settings#xhlds_stats_players_json); it saves plugins that watch that cvar the work. [`xhlds_stats players`](/docs/xhlds/commands#xhlds_stats) on the console works either way.

**Technical details:** The player lines come before [`xhlds_stats_json`](/docs/xhlds/settings#xhlds_stats_json) changes, so a plugin can collect them and then read the server line.

### `xhlds_stats_net_key` [#xhlds_stats_net_key]

An optional secret that lets the per-player statistics show which players connect from the same network, across all your servers, without storing their addresses.

**Default:** empty. **Since:** xHLDS 3.15.0-hs.6.

**Values:** Empty: no network code in the player lines. A long random value: each player line carries a short code for the player's network, the same code on every server that uses the same value.

**When to change it:** Set it if you run several servers and want to spot many accounts coming from one network. Use the same long random value on every server, in `server.cfg`.

**Technical details:** The code shows up in the player lines of [`xhlds_stats_players_json`](/docs/xhlds/settings#xhlds_stats_players_json) and [`xhlds_stats players json`](/docs/xhlds/commands#xhlds_stats). Keep the value private: anyone who has it can work out the network from the code. The server never sends it to players or the server browser.

### `xhlds_stats_profile` [#xhlds_stats_profile]

How much detail [`xhlds_stats profile`](/docs/xhlds/commands#xhlds_stats) gives about where the server's frame time goes, so you can tell whether lag came from the game, a plugin, the network or the machine.

**Default:** `2`. **Since:** xHLDS 3.15.0-hs.6.

**Values:** `0` not measured. `1` by part of the frame (console commands, player packets, player movement, physics, think and touch, sending to players, Steam, the rest). `2` also by each game function the engine calls (`StartFrame`, `Think`, `Touch`, `PlayerPreThink`, `AddToFullPack` and others).

**When to change it:** Leave it at `2`. Use `0` only if you never look at [`xhlds_stats profile`](/docs/xhlds/commands#xhlds_stats).

**Technical details:** It only measures: it doesn't change how the server runs, in any `-pingboost` mode, apart from the small time measuring takes. A change takes effect when the next statistics window starts. For each late frame it also says whether the time went on the frame's own work or between frames, and what ran most often before late frames.

With Metamod, the time of a game function is Metamod plus all its plugins: the engine cannot tell which AMX Mod X or Metamod plugin used it. Pause plugins one at a time and compare.

### `xhlds_stats_window` [#xhlds_stats_window]

How many seconds of play each [`xhlds_stats`](/docs/xhlds/commands#xhlds_stats) report covers.

**Default:** `60`. **Since:** xHLDS 3.15.0-hs.2.

**Values:** Seconds, from 5 to 3600.

**When to change it:** Shorter windows react faster when you watch a problem as it happens; longer ones smooth out one-off spikes. Plugins that forward the JSON outputs get one update per window.

**Technical details:** [`xhlds_stats`](/docs/xhlds/commands#xhlds_stats) reports the last complete window, [`xhlds_stats now`](/docs/xhlds/commands#xhlds_stats) the one in progress. [`xhlds_stats_json`](/docs/xhlds/settings#xhlds_stats_json), [`xhlds_stats_players_json`](/docs/xhlds/settings#xhlds_stats_players_json) and [`xhlds_stats_profile_json`](/docs/xhlds/settings#xhlds_stats_profile_json) are updated once at the end of each window.

## Crash reports [#crash-reports]

### `xhlds_crash_owner` [#xhlds_crash_owner]

The Steam accounts that may see this server's crash reports on Hostsrc's crash service. Outside Hostsrc's network it is also your consent to send them: without it, nothing leaves the machine.

**Default:** empty. **Since:** xHLDS 3.15.0-hs.6.

**Values:** Up to 8 SteamID64s, comma-separated and in quotes, for example `xhlds_crash_owner "76561198000000001,76561198000000002"`. Empty: on a server outside Hostsrc's network no crash report is sent.

**When to change it:** Set it in `server.cfg` if you run xHLDS outside Hostsrc's network and want Hostsrc to see your crashes. Keep the quotes: without them the console reads only the first ID.

**Technical details:** When the server crashes, it writes a crash report and prints one line on the console (what crashed, the map, the uptime), then restarts as before. After the restart the report goes to Hostsrc's crash service at https://crash.hostsrc.com. On Hostsrc's network that always happens. Anywhere else it happens only when `xhlds_crash_owner` is set.

What is sent: the report and a memory snapshot of the server process, the licence file if there is one, the value of `xhlds_crash_owner`, the xHLDS version and, under Pterodactyl, the panel's server ID. It is encrypted so that only the crash service can read it. The crash page says where the crash happened (xHLDS, the game, Metamod, AMX Mod X, a plugin or module, Steam or a system library) and what to do. We look at every engine crash, and when one is fixed, the page names the update that fixes it. Passwords and player IPs are hidden, and the raw files are deleted after 90 days.

Signing in to the crash service is open to invited beta testers for now.

An entry that is not a SteamID64, and any after the eighth, is ignored with a `WARNING: xhlds_crash_owner: ignoring ...` line. The value is read when an upload starts, so a change counts from the next upload. After a report is sent the console prints `Crash report uploaded:` with a link. Crash reports are for the Linux server; uploads work from 3.15.0-hs.7.

**Note:** [`-nocrashreport`](/docs/xhlds/launch-options#-nocrashreport) turns crash reports and uploads off.

## Outputs for plugins [#outputs-for-plugins]

### `xhlds_stats_players_json` [#xhlds_stats_players_json]

An output for plugins, not a setting: one player's connection statistics as one line of JSON.

**Default:** empty. **Since:** xHLDS 3.15.0-hs.6.

**Values:** A line of JSON for one player. At the end of each [`xhlds_stats_window`](/docs/xhlds/settings#xhlds_stats_window) it is set once for each player of the window, one after another. Setting it yourself has no effect.

**When to change it:** You don't. It is an output that plugins read.

**Technical details:** A plugin reads it by watching the cvar change. Each line has the player's slot, user id and Steam ID, how long they were in the game, round trip, loss each way, choke, rate, update rate, packets a second each way, dropped data and overflows, and why they left if they did. It has no names and no IP addresses; with [`xhlds_stats_net_key`](/docs/xhlds/settings#xhlds_stats_net_key) set it also has a code for the player's network. HLTV proxies get a line marked as a proxy; bots get none.

It is not a server cvar, so it is not sent to players or written to the log. [`xhlds_stats_players 0`](/docs/xhlds/settings#xhlds_stats_players) stops it being set. [`xhlds_stats players json`](/docs/xhlds/commands#xhlds_stats) prints the same lines on the console.

### `xhlds_stats_profile_json` [#xhlds_stats_profile_json]

An output for plugins, not a setting: the last profiled window of [`xhlds_stats profile`](/docs/xhlds/commands#xhlds_stats) as one line of JSON.

**Default:** empty. **Since:** xHLDS 3.15.0-hs.6.

**Values:** A line of JSON, updated once at the end of each [`xhlds_stats_window`](/docs/xhlds/settings#xhlds_stats_window) while [`xhlds_stats_profile`](/docs/xhlds/settings#xhlds_stats_profile) is above `0`. Setting it yourself has no effect.

**When to change it:** You don't. It is an output that plugins read.

**Technical details:** For plugins that forward the frame profile, like [`xhlds_stats_json`](/docs/xhlds/settings#xhlds_stats_json). The line is long: an AMX Mod X plugin that reads it needs `#pragma dynamic 16384` or more. It is not a server cvar, so it is not sent to players or written to the log. [`xhlds_stats profile json`](/docs/xhlds/commands#xhlds_stats) prints the same on the console.

### `xhlds_stats_json` [#xhlds_stats_json]

An output for plugins, not a setting: the last complete [`xhlds_stats`](/docs/xhlds/commands#xhlds_stats) window as one line of JSON.

**Default:** empty. **Since:** xHLDS 3.15.0-hs.2.

**Values:** A line of JSON, updated once at the end of each [`xhlds_stats_window`](/docs/xhlds/settings#xhlds_stats_window). Empty until the first window ends. Setting it yourself has no effect.

**When to change it:** You don't. It is an output that plugins read.

**Technical details:** Meant for plugins that forward the server's statistics, for example to a metrics database. It holds what [`xhlds_stats`](/docs/xhlds/commands#xhlds_stats) shows (frame rate, frame times, late frames), how the players' connections did over the window (round trip, loss, choke, dropped data, over all players and for the worst of them), and with the frame profile on, what was behind late frames. HLTV proxies and bots are left out of the player values.

It is set after the player lines of [`xhlds_stats_players_json`](/docs/xhlds/settings#xhlds_stats_players_json), so when it changes, a plugin knows the window is complete. It is not a server cvar: it is not sent to players, written to the log or shown in the server browser. [`xhlds_stats json`](/docs/xhlds/commands#xhlds_stats) prints the same line on the console.